(FILECREATED "12-FEB-74 18:21:17" PUP5)
(DEFINEQ
(@
(LAMBDA (C)
C))
(A:BEING:ORDER
(LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2))))
(A:BEING:WHEN
(LAMBDA (BB)
(SETQ SUM 0)
(MAPC (GETP BB WHEN)
(FUNCTION (LAMBDA (W)
(COND
((EVAL (CAR W))
(SETQ SUM (PLUS SUM (EVAL (CADR W)))))))))
SUM))
(AD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(REMPROP X SPEC:WHY))))
(MAKEFILE (QUOTE PUP5))))
(ADD:BEING
(LAMBDA (B TREAD)
(SET B B)
(PUT B BEING T)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(PRIN1 X)
(PRIN1 " ")
(COND
((SETQ TREAD (READ))
(PUT B X TREAD))))))
(PRIN1 "*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SEMI:COMPILE B)
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER WRITE:PROGRAM PUP5FNS)
(COND
((RATOM)
(AD (LIST B)))
(T (SETQ PUP5FNS (CONS B PUP5FNS))
T)))
((RATOM)
(AD NIL))
((LENGTH PUP5FNS)))))
(ADD:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(SETQ EFFECTS:TABLE (APPEND EFFECTS:TABLE TEMPG))
(SORT EFFECTS:TABLE CAAR:ORDER)))
(ADD:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(SETQ IDEN:TABLE (APPEND IDEN:TABLE TEMPG))
(SORT IDEN:TABLE CAAR:ORDER)))
(ASSERTIONS
(LAMBDA (TEMPA)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SETQ TEMPA (CONS (LIST L (EVAL L))
TEMPA)))))
TEMPA))
(ATOMP
(LAMBDA (SOMETHING)
(ATOM SOMETHING)))
(ATTENTION:DEMONS
(LAMBDA NIL T))
(CAAR:ORDER
(LAMBDA (O1 O2)
(CAR:ORDER (CAR O1)
(CAR O2))))
(CAR:ORDER
(LAMBDA (O1 O2)
(COND
(O1 (COND
(O2 (COND
((EQUAL (CAR O1)
(CAR O2))
(CAR:ORDER (CDR O1)
(CDR O2)))
((ATOM (CAR O1))
(ALPHORDER (CAR O1)
(CAR O2)))
((ATOM (CAR O2))
NIL)
(T (CAR:ORDER (CAR O1)
(CAR O2)))))
(T NIL)))
(T T))))
(CHANGEB
(LAMBDA (B:NAME B:PART)
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(COND
((EQUAL B:PART MAIN:EFFECTS)
(REMOVE:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(REMOVE:IDEN B:NAME)))
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
(COND
((NULL TEMP)
(REMPROP B:NAME B:PART))
((EQUAL B:PART MAIN:EFFECTS)
(ADD:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(ADD:IDEN B:NAME)))
T))
(CHANGEP
(LAMBDA (P)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ X (GETP B P))
(PRINT B)
(COND
((ATOM X)
(PRIN1 "SORRY, PART IS NIL. NEW PART ....... ")
(SETQ X (READ)))
(T (EDITV X)))
(PUT B P X))))))
(CLASS
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(COLON:BACK
(LAMBDA (LL)
(SETQ MM (CAR LL))
(SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E)))))
(SETQ LL (CONS MM LL))
(PACK LL)))
(COLON:BREAK
(LAMBDA (E)
(PROG (UP RP)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL (COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP))))
(COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP)))))
(SETQ UP (CDR UP))
(GO LL))))
(COMMENT
(NLAMBDA FORM
(CONS COMMENT (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(CSORT
(NLAMBDA X
(MAPC X (FUNCTION (LAMBDA (L)
(SET L (SORT (COPY (EVAL L)))))))))
(DEFERRAL:DEMON
(LAMBDA NIL
(MAPCAR UNDEFERRED:DECISION:LIST DEFER:DECISION)
T))
(DIMENSION1
(LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION2
(LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION3
(LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR)))))
(DISK:DUMP
(LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE)))
(DOT:PROD
(LAMBDA (L1 L2)
(COND
(L1 (PLUS (TIMES (CAR L1)
(CAR L2))
(DOT:PROD (CDR L1)
(CDR L2))))
(T 0))))
(DUMP:BEING
(LAMBDA (B)
(PRIN1 "************************* ")
(PRINT B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(COND
((SETQ X2 (GETP B X))
(PRINT X)
(PP X2)
(TERPRI))))))
(QUOTE FINISHED)))
(ENTER
(LAMBDA (EXPERTISE)
(SETQ NEW:F:NUMBER 0)
(SETQ LABEL:COUNTER 0)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(START EXPERTISE)
(PRIN1 "
EXITING FROM THE SYSTEM.
")))
(FAD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (COPY (APPEND PUP5FNS L IS:BEING:LIST))))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (PRIN1 " FULL PUP FILE; USE MAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS)))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS IS:BEING:LIST))
T))
(FAST:BEING:COMPLEX
(LAMBDA (B)
(COND
((NOT (ATOM B))
(SETQ B (CAR B))))
(COND
((GETP B COMPLEXITY:VECTOR)
(DOT:PROD (QUOTE (.1 .6 .3))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL)))
(T 1.0))))
(FIRST:FEW
(LAMBDA (L)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N))))
(FIRSTN
(LAMBDA (N L)
(PROG (TTT)
LLL (COND
((ZEROP N)
(RETURN TTT)))
(SETQ N (SUB1 N))
(SETQ TTT (NCONC1 TTT (CAR L)))
(SETQ L (CDR L))
(GO LLL))))
(FLATTEN
(LAMBDA (L)
(COND
((ATOM L)
(LIST L))
(T (APPEND (FLATTEN (CAR L))
(FLATTEN (CDR L)))))))
(FOREACH
(LAMBDA (X IN SET DO ACTION)
(PROG (RESULT)
START:HERE
(COND
((NULL SET)
(RETURN RESULT)))
(SET X (CAR SET))
(SETQ SET (CDR SET))
(SETQ RESULT (EVAL ACTION))
(GO START:HERE))))
(FOREVER
(LAMBDA NIL NIL))
(FORGETFUL:USER:DEMON
(LAMBDA NIL
(SETQ AWARE:USER:LIST (SETUNION FRINGE:CONCIOUS:LIST (LIST (CAR AWARE:USER:LIST))))
T))
(FRINGE:OF:CONCIOUSNESS:DEMON
(LAMBDA NIL T))
(GETCODE
(LAMBDA (F1 FNAME LEVEL C1 OLDNAME:TAG)
(COND
((MEMBER F1 PRIMITIVE:PROGRAMS:LIST)
F1)
((AND (ATOM F1)
(NOT (EQUAL T (GETP F1 BEING))))
(COND
((OR (NOT (MINUSP LEVEL))
(AND (MATCH (TUPLE A R G ANY1)
(UNPACK F1))))
(SETQ FARGS (NCONC1 FARGS F1))))
F1)
((ATOM F1)
(SETQ F1BACKUP F1)
(GET:NAME (LIST VECTOR F1)
(VECTOR CNAME))
(COND
((NULL OLDNAME:TAG)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR F1BACKUP)
IS UNKNOWN BUT USED IN (@ FNAME))
TYPE:OF:LIST))
(SETQ UNDEFINED:SECTION:LIST (SETUNION UNDEFINED:SECTION:LIST (LIST (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR F1BACKUP)))
))))
CNAME)
((EVAL (GETP (CAR F1)
FORM:CHANGING)))
((MEMBER (CAR F1)
(QUOTE (COMMENT QUOTE NLAMBDA * STRUCTURE)))
F1)
((MATCH (TUPLE SETQ ANY1 ANY2)
F1)
(SETQ C1 ANY2)
(SETQ C11 ANY1)
(COND
((NUMBERP (CAR (LAST (COLON:BREAK ANY1))))
(SETQ CNAME ANY1))
(T (GET:NAME (LIST VECTOR ANY1)
(VECTOR CNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR C11)
IS
(NCONC1 (STRUCTURE (PROPER NAME FOR))
C11)
AND IS USED
IN (VECTOR ASSIGNMENT STATEMENT IN (@ FNAME)))
TYPE:OF:LIST))
(TUPLE SETQ (@ CNAME)
(GETCODE C1 FNAME (SUB1 LEVEL))))
((NUMBERP (CAR (LAST (COLON:BREAK F1))))
(SETQ FN:CALL:LIST (CONS (INVECTOR F1)
FN:CALL:LIST))
F1)
(T (CONS (PROG1 (SETQ C1 (GETCODE (CAR F1)
FNAME
(SUB1 LEVEL)))
(COND
((NUMBERP (CAR (LAST (COLON:BREAK C1))))
(SETQ FN:CALL:LIST (CONS (INVECTOR (CONS C1 (CDR F1)))
FN:CALL:LIST)))))
(GETCODE (CDR F1)
(COND
((MEMBER C1 PRIMITIVE:PROGRAMS:LIST)
FNAME)
(T C1))
(SUB1 LEVEL)))))))
(IDIOM:DEMON
(LAMBDA NIL T))
(INFERENCE:DEMONS
(LAMBDA NIL T))
(INITIALS
(LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E)))))))
(INTUPLE
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
TUPLE)
(MAPCAR L INTUPLE))
(T (CONS TUPLE (MAPCAR L INTUPLE))))))
(INVECTOR
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
VECTOR)
(MAPCAR L INVECTOR))
(T (CONS VECTOR (MAPCAR L INVECTOR))))))
(IRRELEVANT
(LAMBDA (L)
(NOT (EVAL (CDR L)))))
(LUMP:ASSERTIONS
(LAMBDA (L TEMPL TEMPL2)
(SETQ TEMPL NIL)
(SETQ L (ASSERTIONS))
(MAPC L (FUNCTION (LAMBDA (L1)
(SETQ TEMPL (APPEND TEMPL (CADR L1))))))
(SETQ TEMPL2 (COPY TEMPL))
(SETQ TEMPL2 (INTERSECTION TEMPL2 TEMPL2))
(SORT TEMPL2)))
(MAD
(LAMBDA (L)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS SET:OF:BEINGS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS)))))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (APPEND SET:OF:BEINGS PUP5FNS))
T))
(MAIN:WORDS
(LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS)))
(MAKE:SPECIFIC
(LAMBDA (A)
(SETQ IS:SPECIFIC:LIST (CONS A IS:SPECIFIC:LIST))))
(MATCH
(LAMBDA (A B LD)
(SETQ LD (ADD1 (DIFFERENCE (LENGTH B)
(LENGTH A))))
(SETQ MATCH:RESULT T)
(COND
((MINUSP LD)
NIL)
(T (MAPC A (FUNCTION (LAMBDA (A1)
(COND
((MEMB A1 (QUOTE (ANY1 ANY2 ANY3)))
(SET A1 (CAR B))
(SETQ B (CDR B)))
((MEMB A1 (QUOTE (FRAG1 FRAG2)))
(SET A1 (FIRSTN LD B))
(SETQ B (NTH B (ADD1 LD))))
((EQUAL A1 (CAR B))
(SETQ B (CDR B)))
((LISTP A1)
(SETQ MATCH:RESULT (AND MATCH:RESULT (MATCH A1 (CAR B))))
(SETQ B (CDR B)))
(T (SETQ MATCH:RESULT NIL))))))))
(AND (NULL B)
MATCH:RESULT)))
(MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ MINNUM UNKNOWN)
(CADAR (CDDDDR MIN))))))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(COND
((OR (LESSP (SETQ TV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ NEWNUM UNKNOWN)
(CADAR (CDDDDR ELE))))))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
MIN))
(MOVE:BEING
(LAMBDA (B:OLD B)
(SET B B)
(PUT B BEING T)
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(PUT B P (COPY (GETP B:OLD P))))))
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER ENCODE PUP5FNS)
(SETQ PUP5FNS (CONS B PUP5FNS))))
(SEMI:COMPILE B)))
(MULT:INTERSECTION
(LAMBDA (L)
(COND
((CDDR L)
(SETINTERSECTION (CAR L)
(MULT:INTERSECTION (CDR L))))
(T (SETINTERSECTION (CAR L)
(CADR L))))))
(NEW:IDEN
(LAMBDA NIL
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(PUT B IDEN (LIST (LIST (QUOTE AND)
(LIST (QUOTE EQUAL)
(QUOTE (CAR LI))
B)
(LIST (QUOTE EQUAL)
(QUOTE (LENGTH (CDR LI)))
(LENGTH (GETP B EXPLICIT:ARGS))))
(LIST (QUOTE LIST)
B
(LIST TRANSLATE (QUOTE (CADR LI)))))))))))
(NEW:LEVEL
(LAMBDA (EXPERTISE)
(PROG (NEWL)
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L (SETQ NEWL (COND
((NUMBERP EXPERTISE))
((RATOM))))
(SETQ EXPERTISE NIL)
(SETQ PERMANENT:USER:INTERRUPT:DEMONS (SELECTQ NEWL
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS))))
(NULLIFY
(LAMBDA (L)
(SET (CAR L)
NIL)
(COND
((CDR L)
(NULLIFY (CDR L))))))
(OPPOSITE
(LAMBDA (WORD)
(SELECTQ WORD
(RELEVANT (QUOTE IRRELEVANT))
(IRRELEVANT (QUOTE RELEVANT))
(STATIC (QUOTE DYNAMIC))
(DYNAMIC (QUOTE STATIC))
(LE (QUOTE GT))
(GT (QUOTE LE))
(LT (QUOTE GE))
(GE (QUOTE LT))
(HAPPY (QUOTE SAD))
(SAD (QUOTE HAPPY))
(QUOTE TEMPORARILY))))
(OUTNIL
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
NIL)
(OUTNIL (CDR S)))
(T (CONS (OUTNIL (CAR S))
(OUTNIL (CDR S)))))))
(OUTQUOTE
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
(QUOTE QUOTE))
(CONS TUPLE (OUTQUOTE (CADR S))))
(T (CONS (OUTQUOTE (CAR S))
(OUTQUOTE (CDR S)))))))
(OUTTUPLE
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
TUPLE)
(OUTTUPLE (CDR S)))
(T (CONS (OUTTUPLE (CAR S))
(OUTTUPLE (CDR S)))))))
(OUTVECTOR
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
VECTOR)
(OUTVECTOR (CDR S)))
(T (CONS (OUTVECTOR (CAR S))
(OUTVECTOR (CDR S)))))))
(PERMIT:DETAILED:DECISION
(LAMBDA NIL
(TERPRI)
(PRIN1 "SHOULD I DISCUSS RAMIFICATIONS?")
(COND
((EQUAL (RATOM)
YES)
(PRIN1 "I ASK NOW BECAUSE")
(PRIN1 (CADDDR D))
(PRIN1 "HAS THE NON-NULL VALE")
(PRIN1 (EVAL (CADDDR D)))
(COND
((MEMBER WHY (CADR D))
(PRIN1 "THIS, IN TURN, IS")
(PRIN1 (CDADR (MEMBER WHY (CADR D))))
(TERPRI)))
(PRIN1 " THE EFFECT OF
ANSWERING YES IS ")
(PRIN1 (CDDADR (MEMBER AFFECTS (CADR D))))
(TERPRI)
(PRIN1 "THE EFFECT OF ANSWERING NO IS THUS NO:EFFECT")))))
(PERMIT:USER:INTERRUPT
(LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1 "
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (RATOM)
(Y (PROCESS:USER:INTERRUPT))
(N T)
(PROGN (PRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT)))))
(POP:DEMONS
(LAMBDA NIL
(SETQ CURRENT:DEMONS (CAR DEMON:STACK))
(SETQ DEMON:STACK (CDR DEMON:STACK))
T))
(PROCEDURE:INTERSECTION
(LAMBDA (P P1 YTEMP)
(SETQ P1 (CAAR P))
(COND
((MEMBER NIL (MAPCAR (CDR P)
(FUNCTION (LAMBDA (P2)
(EQUAL (CAR P2)
P1)))))
NIL)
((EQUAL P1 (QUOTE PROGN))
(SETQ YTEMP (MULT:INTERSECTION (MAPCAR P (QUOTE CDR))))
(COND
((LESSP (LENGTH YTEMP)
2)
(CAR YTEMP))
(T (CONS P1 YTEMP))))
(T NIL))))
(PROCEDURE:PULLOUT
(LAMBDA (PIECE BODY PPRESULT)
(SETQ PPRESULT (COND
((EQUAL (CAR BODY)
(CAR PIECE))
(CONS (CAR BODY)
(SETDIFFERENCE (CDR BODY)
(CDR PIECE))))
(T (CONS (CAR BODY)
(SETDIFFERENCE BODY (LIST (CAR BODY)
PIECE))))))
(COND
((MATCH (TUPLE PROGN ANY1)
PPRESULT)
ANY1)
(T PPRESULT))))
(PROCEDURE:SUBSET
(LAMBDA (A1 A2)
(NOT (MEMBER NIL (MAPCAR (CDR A1)
(FUNCTION (LAMBDA (A3)
(MEMBER A3 A2))))))))
(PROCESS:USER:INTERRUPT
(LAMBDA NIL
(PROG (RESPONSE BC BC1 BC2)
(COND
((NOT EXPERTISE)
(PRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK))))
(PRIN1 " TYPE ? OR ")))
(SETQ BC (CAR BEING:STACK))
(SETQ BC1 NIL)
(SETQ BC2 (CDR BEING:STACK))
L (PRIN1 " REQUEST: ")
(SELECTQ (SETQ RESPONSE (READ))
(CH (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(? (PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
")
(PRIN1 "NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (Y)
(PRIN1 Y)
(PRIN1 " PRINT OUT ")
(PRIN1 Y)
(PRIN1 " WITH RESPECT TO CURRENT BEING
")))))
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN T))
(FAIL (RETURN NIL))
(SPEC:WHEN (PRINT (MAPCAR (GETP BC WHEN)
(FUNCTION (LAMBDA (W)
(TUPLE (CAR W)
IS
(SETQ W2 (EVAL (CAR W)))
SO WE (COND
(W2 (QUOTE DO))
(T (QUOTE DONT)))
ADD IN THE WEIGHT (CADR W) WHICH IN THE CURRENT CASE IS
(EVAL (CADR W)) ;THE
EXPLANATION IS
(EVAL (CADDR W)))))))
(PRINT (TUPLE THE FINAL WHEN VALUE IS THUS (A:BEING:WHEN BC))))
(BEING (PRINT BC))
(CONTROL:HISTORY (PRIN1 BC1)
(PRIN1 " *** ")
(PRIN1 BC)
(PRIN1 " *** ")
(PRIN1 BC2)
(TERPRI))
(DEMONS (PRIN1 CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT DEMON:STACK))
(OLDER (SETQ BC1 (NCONC1 BC1 BC))
(SETQ BC (CAR BC2))
(SETQ BC2 (CDR BC2))
(PRINT BC))
(NEW:LEVEL (NEW:LEVEL))
(YOUNGER (SETQ BC2 (CONS BC BC2))
(SETQ BC (LAST BC1))
(SETQ BC1 (REVERSE (CDR (REVERSE BC1))))
(PRINT BC))
(OLDEST (SETQ BC (LAST BEING:STACK))
(SETQ BC1 (REVERSE (CDR (REVERSE BEING:STACK))))
(SETQ BC2 NIL)
(PRINT BC))
(YOUNGEST (SETQ BC (CAR BEING:STACK))
(SETQ BC2 (CDR BEING:STACK))
(SETQ BC1 NIL)
(PRINT BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (OUTTUPLE (GETP BC RESPONSE)))))
((MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (OUTVECTOR (EVAL (GETP BC RESPONSE)))))
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (PRIN1 "
*** ERROR *** TYPE ? FOR ASSISTANCE **********
")
(GO L))))
(GO L))))
(PROGRAM:WRITING:DEMONS
(LAMBDA NIL T))
(PSYCHOLOGY:DEMON
(LAMBDA NIL T))
(PULLOUT
(LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L)))))))
(PUSH:DEMONS
(LAMBDA (NEW:DEMONS)
(SETQ NEW:DEMO (SETDIFFERENCE NEW:DEMONS CURRENT:DEMONS))
(SETQ CURRENT:DEMONS (APPEND NEW:DEMO CURRENT:DEMONS))
(SETQ DEMON:STACK (CONS CURRENT:DEMONS DEMON:STACK))))
(REINVESTIGATION:DEMON
(LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADDDR D))
(REINVESTIGATE:DECISION D))
(T NOT:TIME:YET)))))
T))
(RELEVANT
(LAMBDA (L)
(EVAL (CDR L))))
(REMOVE:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ EFFECTS:TABLE (PULLOUT E EFFECTS:TABLE)))))))
(REMOVE:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ IDEN:TABLE (PULLOUT E IDEN:TABLE)))))))
(SEMI:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (TUPLE (COND
((GETP B NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ))))
(LIST (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK))))
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS)))
(LIST (GETP B EXPLICIT:ARGS:CHECK))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(GETP B COMMENTS)
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X)))))
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
(COND
((GETP B INHIBIT:CURRENT:DEMONS)
(QUOTE ((NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(T (QUOTE ((NOT (MEMBER NIL (MAPCAR (APPEND CURRENT:DEMONS
USER:INTERRUPT:DEMONS)
(QUOTE APPLY*))))))))
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
(QUOTE ((NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(COND
((GETP B PREDICATE)
(QUOTE ((COND
(FN:VALUE)
(T FALSE)))))
(T (QUOTE (FN:VALUE)))))
(QUOTE (SETQ BEING:STACK (CDR BEING:STACK)))
(QUOTE (POP:DEMONS))))))))))
(SET:UP:EFFECTS:TABLE
(LAMBDA (TEMPTOO)
(SETQ E:TABLE NIL)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B MAIN:EFFECTS))))))
(SETQ EFFECTS:TABLE (COPY E:TABLE))
(SORT EFFECTS:TABLE CAAR:ORDER)
(LENGTH EFFECTS:TABLE)))
(SET:UP:IDEN:TABLE
(LAMBDA (TEMPTOO)
(SETQ E:TABLE FUNDAMENTAL:IDEN:TABLE)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B IDEN))))))
(SETQ IDEN:TABLE (COPY E:TABLE))
(SORT IDEN:TABLE CAAR:ORDER)
(LENGTH IDEN:TABLE)))
(SETDIFFERENCE
(LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND (COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1))))
(SETDIFFERENCE (CDR S1)
S2))))))
(SETINTERSECTION
(LAMBDA (S1 S2)
(INTERSECTION S1 S2)))
(SETUNION
(LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1)))
(SINGLETON
(LAMBDA (S)
(NULL (CDR S))))
(SIZE
(LAMBDA (STRUC)
(ADD1 (IQUOTIENT (COUNT STRUC)
2))))
(SPECIFICITY:CHECK:DEMON
(LAMBDA (ANYTHING)
(MAPC (SETDIFFERENCE PUP:WANTS:LIST IS:SPECIFIC:LIST)
MAKE:SPECIFIC)
T))
(START
(LAMBDA (EXPERTISE)
(PROG NIL
L1 (SETQ BEING:STACK NIL)
(SETQ BECAUSE (VECTOR))
(SETQ FORCE:TRANSLATE NIL)
(SETQ DEMON:STACK NIL)
(SETQ CURRENT:DEMONS NIL)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SET L NIL))))
L2 (COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L (SETQ PERMANENT:USER:INTERRUPT:DEMONS (SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
L3 (SERVE)
L4 (COND
(EXPERTISE (PRIN1
"
FINISHED CURRENT SERVICE; WHAT SHOULD I DO? TYPE ONE OF:
1 EXIT FROM SYSTEM
2 CONTINUE SERVING, AS BEFORE
3 CONTINUE SERVING, BUT GET A NEW USER INTERRUPT LEVEL
4 REINITIALIZE SYSTEM AND START FROM BEGINNING AGAIN
OK, GO .......... "))
(T (PRIN1 "
FINISHED SERVICE. 1 EXIT; 2 CONTINUE; 3 NEW LEVEL; 4 START OVER ")))
(SELECTQ (RATOM)
(2 (GO L3))
(3 (GO L2))
(4 (GO L1))
(1 "EXITING SYSTEM")
(PRIN1 "NO, NO!!!!! ")
(GO L4)))))
(STRUCTURE
(NLAMBDA FORM
(CONS STRUCTURE FORM)))
(SUBSTITUTE
(LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (COPY (EVAL LIST:STRUCTURE))))))
(TEMPORARILY
(LAMBDA (L)
(EVAL (CDR L))))
(TRACE:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (QUOTE (LAMBDA))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ BEING:FLAG DEMON:FLAG))))
(LIST (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK)))))
(LIST (LIST (QUOTE PRINT)
(GETP B EXPLICIT:ARGS:CHECK)))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X)))))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X))))))
(QUOTE ((PRINT "COMMENTS BEGINNING")))
(GETP B COMMENTS)
(QUOTE ((PRINT "COMMENTS ENDING")))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE))))
(QUOTE ((PRIN1 "NOT1 ")))
(QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(LIST (LIST (QUOTE PRINT)
(LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE))))
(QUOTE ((PRIN1 "NOT2 ")))
(QUOTE ((NOT (MEMBER NIL (PRINT (MAPCAR FINAL:CO:REQ SATISFY))))))
(QUOTE ((PRINT (POP:DEMONS))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PRINT)
(LIST SATISFY X)))))
(QUOTE ((SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR (PRINT BEING:STACK)))))
(COND
((GETP B PREDICATE)
(QUOTE ((PRINT (COND
(FN:VALUE)
(T FALSE))))))
(T (QUOTE ((PRINT FN:VALUE))))))
(QUOTE (PRINT (TUPLE BEING:FLAG (@ BEING:FLAG)
DEMON:FLAG
(@ DEMON:FLAG))))
(QUOTE (PRINT (COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS)))))))))))))
(TRY:TO:SATISFY
(LAMBDA (SUBGOAL)
(COND
((SATISFY SUBGOAL)
T)
(T (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ))))))
(TUPLE
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(USER:INTERRUPT:AT:ADAPTING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ADAPT:PRECONCEIVED:FUNCTION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:CODING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ENCODE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:CODING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:DEBUG
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
CLARIFY:IMPROBABLE:SITUATION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:END
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
OPTIMIZE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:END USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:PHASES
(LAMBDA (S:EXP)
(COND
((MEMBER (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES))
(PERMIT:USER:INTERRUPT)))))
(VECTOR
(NLAMBDA FORM
(CONS VECTOR (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(VECTOR:AVERAGE
(LAMBDA (L)
(LIST .8 .8 .8 .8)))
(WHEN:VALUE
(LAMBDA (B:CALL)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
(MAP2C EXP:A (CDR B:CALL)
(FUNCTION (LAMBDA (NEWARG OLDARG)
(SET NEWARG OLDARG))))
(COND
((EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
(A:BEING:WHEN (CAR B:CALL)))
(T -1000))))
(Z@
(LAMBDA (X)
X))
)
(LISPXPRINT (QUOTE PUP5FNS)
T)
(RPAQQ PUP5FNS
(@ A:BEING:ORDER A:BEING:WHEN AD ADD:BEING ADD:EFFECTS ADD:IDEN ASSERTIONS ATOMP ATTENTION:DEMONS CAAR:ORDER
CAR:ORDER CHANGEB CHANGEP CLASS COLON:BACK COLON:BREAK COMMENT CSORT DEFERRAL:DEMON DIMENSION1 DIMENSION2
DIMENSION3 DISK:DUMP DOT:PROD DUMP:BEING ENTER FAD FAST:BEING:COMPLEX FIRST:FEW FIRSTN FLATTEN FOREACH
FOREVER FORGETFUL:USER:DEMON FRINGE:OF:CONCIOUSNESS:DEMON GETCODE IDIOM:DEMON INFERENCE:DEMONS INITIALS
INTUPLE INVECTOR IRRELEVANT LUMP:ASSERTIONS MAD MAIN:WORDS MAKE:SPECIFIC MATCH MINIMUM MOVE:BEING
MULT:INTERSECTION NEW:IDEN NEW:LEVEL NULLIFY OPPOSITE OUTNIL OUTQUOTE OUTTUPLE OUTVECTOR
PERMIT:DETAILED:DECISION PERMIT:USER:INTERRUPT POP:DEMONS PROCEDURE:INTERSECTION PROCEDURE:PULLOUT
PROCEDURE:SUBSET PROCESS:USER:INTERRUPT PROGRAM:WRITING:DEMONS PSYCHOLOGY:DEMON PULLOUT PUSH:DEMONS
REINVESTIGATION:DEMON RELEVANT REMOVE:EFFECTS REMOVE:IDEN SEMI:COMPILE SET:UP:EFFECTS:TABLE
SET:UP:IDEN:TABLE SETDIFFERENCE SETINTERSECTION SETUNION SINGLETON SIZE SPECIFICITY:CHECK:DEMON START
STRUCTURE SUBSTITUTE TEMPORARILY TRACE:COMPILE TRY:TO:SATISFY TUPLE USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END USER:INTERRUPT:AT:PHASES VECTOR
VECTOR:AVERAGE WHEN:VALUE Z@))
(LISPXPRINT (QUOTE PUP5VARS)
T)
(RPAQQ PUP5VARS
(AFFECTS:ALL AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE WHEN:ALL:DEFER:DECISION:KNOWLEDGE
BOOLEAN:DEFER:DECISION:KNOWLEDGE WHEN:ALL DICHOTOMY:DEFER:DECISION:KNOWLEDGE
ADAPTATION:DEFER:DECISION:KNOWLEDGE ALTERNATIVES:DEFER:DECISION:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
EQUAL ISNT DOESNT EQUALS IS DOES RESULTS DICHOTOMY:DEFER:DECISION:KNOWLEDGE
DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE ADJECTIVES DEFINITION:RESOLVE:DECISION:KNOWLEDGE
DEFINITION:DEFER:DECISION:KNOWLEDGE UNKNOWN COMMENT GO LABEL:COUNTER KNOWLEDGE
BOOLEAN:RESOLVE:DECISION:KNOWLEDGE SOMEOF:RESOLVE:DECISION:KNOWLEDGE YES ASSERT:LISTS
SOMEOF:DEFER:DECISION:KNOWLEDGE IS:BEING:LIST BEING BREAKUP:LIST UNTIL FUNDAMENTAL:IDEN:TABLE
SINCE FOREVER PRIMITIVE:PROGRAMS:LIST PRIMITIVE:VARS:LIST Y N NOT:TIME:YET CALL
COMPILABLE:BEING:PARTS EFFECTS:TABLE EVAL PARTS EVAL:BEING:PARTS FALSE IDEN:TABLE INFERIOR
MINOR:WORDS ING NAME NON:EVAL:BEING:PARTS NON:EXECUTABLE PERMANENT:KNOWN:NAMES
PROGRAM:WRITING:PHASES SET:OF:BEING:PARTS SET:OF:BEINGS SUPERIOR
(COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
(P (MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(WIDEPAPER T))
(P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION "))))
(RPAQQ AFFECTS:ALL AFFECTS:ALL)
(RPAQQ AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR THE BASIC STRUCTURE OF FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE AMOUNT OF EFFORT ANY1 SHOULD SPEND ON FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR HOW ANY1 STORES FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF STORING)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE ANY2 ALGORITHM)
(TUPLE MEMBER NIL (TUPLE MAPCAR DOING:PUP:LIST (TUPLE FUNCTION (TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT
(TUPLE MATCH
(VECTOR ANY1 TYPE OF
(LIST VECTOR
ANY2))
PD)))))))
((VECTOR CODE INVOLVING ANY1)
(TUPLE MEMBER NIL (TUPLE MAPCAR (TUPLE FLATTEN DOING:PUP:LIST)
(TUPLE FUNCTION
(TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT (TUPLE OR (TUPLE EQUAL (@ ANY1)
PD)
(TUPLE MEMBER (@ ANY1)
(TUPLE COLON:BREAK PD))
(TUPLE EQUAL (@ ANY1)
(TUPLE COLON:BACK
(TUPLE REVERSE
(TUPLE CDR
(TUPLE REVERSE
(TUPLE
COLON:BREAK PD))
)))))))))))
((VECTOR WHAT INFORMATION ANY1 MAY USE TO ANY2 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY2 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR ANY1 DETAILS)
(TUPLE MEMBER (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
DOING:PUP:LIST))))
(RPAQQ WHEN:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR BEFORE DECIDING FIRMLY HOW TO ANY1 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR BEFORE ANY FRAG2 ROUTINES ARE FINALIZED)
(COND (FRAG2 (TUPLE MEMBER T (TUPLE MAPCAR (TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
(TUPLE FUNCTION (TUPLE LAMBDA (TUPLE X)
(TUPLE AND (TUPLE ATOM X)
(TUPLE SETINTERSECTION (INTUPLE FRAG2)
(TUPLE GETP X GENERALIZATIONS)))))))
)
(T (TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST))))))
(RPAQQ BOOLEAN:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ WHEN:ALL WHEN:ALL)
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ADAPTATION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ALTERNATIVES:DEFER:DECISION:KNOWLEDGE ((COND ((AND (NOT (MEMBER NIL (MAPCAR (SETQ C (CDADR DEC))
(FUNCTION (LAMBDA (D)
(GETP D BEING))))
))
(SETQ PROC (INVECTOR (PROCEDURE:INTERSECTION
(MAPCAR C (FUNCTION (LAMBDA
(D)
(GETP D
META:CODE)))))
)))
(COND ((EQUAL TASK (INVECTOR (LAST DEC)))
(SETQ TNAME TASK:NAME))
(T (GET:NAME (INVECTOR (LAST DEC))
(VECTOR TNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ TNAME)
TYPE OF (LAST DEC)
IS
(VECTOR TEMPORARILY
(@ PROC)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (@ TNAME)
TYPE OF
(INVECTOR
(LAST DEC)))
ENCODABLE:SECTION:LIST))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION (SETDIFFERENCE (COND ((LESSP (LENGTH PROC)
3)
(LIST PROC))
(T PROC))
ABLE:PUP:LIST)
UNDEFINED:SECTION:LIST))
(TUPLE PROCEDURE:SUBSET (@ PROC)
ABLE:PUP:LIST))
(T NIL))))
(RPAQQ APPLIED:SO:AS:TO:KEEP APPLIED:SO:AS:TO:KEEP)
(RPAQQ EQUAL EQUAL)
(RPAQQ ISNT ISNT)
(RPAQQ DOESNT DOESNT)
(RPAQQ EQUALS EQUALS)
(RPAQQ IS IS)
(RPAQQ DOES DOES)
(RPAQQ RESULTS RESULTS)
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE (PROGN (SETQ ENT2 (CADR (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST))))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(LIST VECTOR
ENT2)
IS ANY2 AND
IS USED IN
(CADR CHOICE))
TOL)
(SETQ ARG1 ANY1))))))
(PRINT (TUPLE ABOVE, ARG1 REFERS TO (@ ARG1)))
(COND ((SETQ TRESULT (NLSETQ (EVAL (CADDR (CADR D)))))
(SETQ TRESULT (CAR TRESULT))
(PRIN1
"
AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
USER CHANNEL AFTER ALL!!!
"))
(T (PRIN1 (CONCAT
"
SINCE THE DECISION IS DICHOTOMOUS, TYPE A 1 OR A 2
1 MEANS THAT " (CADR (CADDR (CADR D)))
" IS CORRECT.
2 MEANS THAT "
(CADDR (CADDR (CADR D)))
" IS CORRECT.
USER: "))
(SETQ TRESULT (EQUAL (RATOM)
1))))
(SETQ NEWPIECE (CDADR (MEMBER RESULTS (CADR D))))
(SETQ NEWPIECE (COND (TRESULT (CAR NEWPIECE))
(T (CADR NEWPIECE))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF
(INVECTOR (LAST (CADR D)))
IS
(INVECTOR (EVAL NEWPIECE)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
(RPAQQ ADJECTIVES (STATIC DYNAMIC HARD SOFT EASY SIMPLE COMPLEX BIG LITTLE SMALL LARGE))
(RPAQQ DEFINITION:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ DEFINED:OBJECT (CAR (LAST (CDADR D))))
(COND ((NOT (MEMBER NIL (MAPCAR UNDEFINED:SECTION:LIST (FUNCTION
(LAMBDA (US1)
(NOT (COND ((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR
DEFINED:OBJECT)
FRAG1)
US1)
(SETQ HOLD:ANY1 ANY1)
(SETQ HOLD:FRAG1 FRAG1)
T))))))))
(SETQ HOLD:ANY1 DEFINED:OBJECT)
(SETQ HOLD:FRAG1 NIL)))
(PRIN1 "SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
TYPE IN THE DEFINITION OF ")
(PRIN1 HOLD:ANY1)
(COND ((AND (SETQ TCALL (SASSOC HOLD:ANY1 (OUTVECTOR FN:CALL:LIST)))
(GETP DEFINED:OBJECT PREDICATE))
(PRIN1 (CONCAT
"
SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
LOGICAL EXPRESSION, WHICH IS TRUE IF " (CADR TCALL)
" IS OF
THE "
(CDADDR TCALL)
" TYPE, AND SHOULD BE FALSE IF IT ISNT OF
THAT TYPE.
"))))
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "USER: ")
(SETQ NEW:INFO:LIST (CONS (VECTOR DEFINE (@ HOLD:ANY1)
AS
(INVECTOR (READ)))
NEW:INFO:LIST))))
(RPAQQ DEFINITION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ UNKNOWN UNKNOWN)
(RPAQQ COMMENT COMMENT)
(RPAQQ GO GO)
(RPAQQ LABEL:COUNTER 1)
(RPAQQ KNOWLEDGE KNOWLEDGE)
(RPAQQ BOOLEAN:RESOLVE:DECISION:KNOWLEDGE (PROGN (PRIN1 "SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "NOW TYPE YOUR ANSWER: ")
(COND ((EQUAL (RATOM)
YES)
(SETQ NEW:INFO:LIST (CONS (CDADR (MEMBER AFFECTS
(CADR D)))
NEW:INFO:LIST)))
(T (PRIN1 " OK, SO WE JUST GO ON.")
(TERPRI)
T))))
(RPAQQ SOMEOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PRIN1 "SINCE THE DECISION IS SOME:OF, TYPE ANY NON-NULL SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PRINT (LIST L1 (QUOTE ....)
D1)))))
(PRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PRIN1 "USER: ")
(SETQ IN:SET (READ))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(SETQ PROC (PROCEDURE:INTERSECTION (MAPCAR IN:SET:TRANS (FUNCTION (LAMBDA (B)
(GETP B META:CODE))))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(VECTOR REPEATEDLY (INVECTOR PROC)
(APPEND (VECTOR COND)
(MAPCAR IN:SET:TRANS
(FUNCTION
(LAMBDA (IST)
(VECTOR (COND
((EQUAL (LAST IN:SET:TRANS)
(LIST IST))
T)
(T (VECTOR IS:OF:TYPE
ELEMENT
(LIST VECTOR
COMMENT IST)
)))
(INVECTOR
(PROCEDURE:PULLOUT
PROC
(GETP IST META:CODE)))))))
)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ YES YES)
(RPAQQ ASSERT:LISTS
(ABLE:PUP:LIST ABLE:USER:LIST ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST AWARE:PUP:LIST
AWARE:USER:LIST ENCODABLE:SECTION:LIST DOING:PUP:LIST EXECUTABLE:INFO:LIST FRINGE:CONCIOUS:LIST
PARTITIONED:DOMAIN:LIST IS:DEFINED:LIST FN:CALL:LIST IS:SPECIFIC:LIST CODING:WARNING:LIST
RESOLVED:DECISION:LIST KNOWN:NAMES NAMED:EXPRESSION:LIST NEW:INFO:LIST PLAUSIBLE:NAMES:LIST
PUP:SATISFIED:LIST PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST READ:USER:LIST
RELEVANT:INFO:LIST TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST TYPE:OF:LIST
UNDEFERRED:DECISION:LIST USABLE:INFO:LIST USER:WANTS:LIST WRITTEN:PROGRAMS:LIST
DEFERRED:DECISION:LIST UNDEFINED:SECTION:LIST))
(RPAQQ SOMEOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ IS:BEING:LIST
(SOME:PART:OF PARTITION:A:DOMAIN:2 CONCEPT:FORMATION:1 TAKE:HOL:3 HAS:A:NAME:5 ELEM:4 STAT:SCENE:8 PADP:2
CFP:1 HAS:NAME:5 IS:OF:TYPE:5 ELEMENT:4 STATIC:SCENE:8 PAD:2 CF:1 RECOGNIZE:EQUALITY
RECOGNIZE:LITERALS RECOGNIZE:CAR ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS
ASK:USER:ABOUT BETTER CHOOSE:FROM CLASSIFICATORY:CONCEPT:FORMATION COMPARITIVE:CONCEPT:FORMATION
CONCEPT:FORMATION DEFER:DECISION ELEMENT ENCODE EXTRACT:RELEVANT:SUBSET
FILL:IN:UNDEFINED:SECTION GET:HOLD:OF GET:NAME GET:NEW:INFORMATION IS:OF:TYPE MAKE:ENCODABLE
MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION OBTAIN:USABLE:INFORMATION PARTITION:A:DOMAIN
PARTITION:BY:TAKE:CLASS:GET:ELE PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS
PROPOSE:PLAUSIBLE:NAMES REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION SATISFY SCENE SERVE
STUDY:TYPE TAKE:HOLD:OF TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ BEING BEING)
(RPAQQ BREAKUP:LIST (: ; %. , - ?))
(RPAQQ UNTIL UNTIL)
(RPAQQ FUNDAMENTAL:IDEN:TABLE (((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))))
(RPAQQ SINCE SINCE)
(RPAQQ FOREVER FOREVER)
(RPAQQ PRIMITIVE:PROGRAMS:LIST
(AND OR NOT COND T MAPC MAPCAR LAMBDA FUNCTION PLUS TIMES LIST APPEND CONS CAR CDR CADR CADDR CADDDR CADAR
MINUS MINUSP QUOTIENT ADD1 SUB1 SET SETQ NULL QUOTE EVAL LESSP EQUAL TEMPORARILY NIL RELEVANT IRRELEVANT
PROG PROGN CDAR CDDR CAAR CAADR CAAAR CDADR PROG1 READ PRINT PRIN1 PRIN2))
(RPAQQ PRIMITIVE:VARS:LIST (T NIL 0 1 2 3 4 5 6 7 8 9 10 -1 -2 -3))
(RPAQQ Y NOBIND)
(RPAQQ N 2)
(RPAQQ NOT:TIME:YET NOT:TIME:YET)
(RPAQQ CALL CALL)
(RPAQQ COMPILABLE:BEING:PARTS (META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES EXPLICIT:ARGS
EXPLICIT:ARGS:CHECK IMPLICIT:ARGS DEMONS INHIBIT:CURRENT:DEMONS))
(RPAQQ EFFECTS:TABLE (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION))
((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION:1))
((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2))))
((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1)))
((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1)))
((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1)))
((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN))
((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN:2))
((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1)))
((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D))))
((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND))))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))))
(RPAQQ EVAL EVAL)
(RPAQQ PARTS PARTS)
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY PREDICATE DATA:STRUCTURE INHIBIT:CURRENT:DEMONS FORM:CHANGING
ENCODABLE NON:EVAL:ARGS NLAMBDA))
(RPAQQ FALSE FALSE)
(RPAQQ IDEN:TABLE (((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T)))
((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T))))))
((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2))
(VECTOR MESSAGE (CADR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI)))
((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T)))
((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI)))
((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI)))
((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((EQUAL LI (LIST SCENE))
(VECTOR SCENE))
((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE))
((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))
((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1)))
((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1))))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1))))
((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI)))
((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T)))
((MATCH (TUPLE A DESCRIPTION OF A FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN:2))
((MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI)
(VECTOR MESSAGE (INVECTOR FRAG1)))
((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN:2))
((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(CDR (TRANSLATE (LIST VECTOR ANY1)
T))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T))))))
((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION))
((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION:1)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION:1))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T)))))
((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((Z@ (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(PROGN (PRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT (TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (RATOM)
(QUOTE (YES Y PROBABLY)))))
(OR (SET ANY1 ANY1)
T)))
ANY1)))
(RPAQQ INFERIOR INFERIOR)
(RPAQQ MINOR:WORDS (A AT DO DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE))
(RPAQQ ING ING)
(RPAQQ NAME NAME)
(RPAQQ NON:EVAL:BEING:PARTS (IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES))
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ PERMANENT:KNOWN:NAMES NIL)
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION USE:INFORMATION FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE OPTIMIZE))
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS
MINOR:EFFECTS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS AFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES PREDICATE DATA:STRUCTURE ENCODABLE
INHIBIT:CURRENT:DEMONS FORM:CHANGING))
(RPAQQ SET:OF:BEINGS
(SOME:PART:OF RECOGNIZE:EQUALITY RECOGNIZE:LITERALS RECOGNIZE:CAR ADD:DEFINITION ADJECTIVE:HANDLER
ANALYZE:IMPLICATIONS ASK:USER:ABOUT BETTER CHOOSE:FROM CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION CONCEPT:FORMATION DEFER:DECISION ELEMENT ENCODE
EXTRACT:RELEVANT:SUBSET FILL:IN:UNDEFINED:SECTION GET:HOLD:OF GET:NAME GET:NEW:INFORMATION
IS:OF:TYPE MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION
OBTAIN:USABLE:INFORMATION PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS PROPOSE:PLAUSIBLE:NAMES
REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION SATISFY SCENE SERVE STUDY:TYPE TAKE:HOLD:OF
TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ SUPERIOR SUPERIOR)
(PUTPROPS SOME:PART:OF BEING T
EXPLICIT:ARGS (LIST:STRUC)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE THIS IS A DESTRUCTIVE FUNCTION; IT BREAKS A PIECE OFF OF (@ LIST:STRUC))
HOW (TUPLE USE SOME PRE:EXISTING TECHNIQUE TO GET THE SIMPLE LISP PROGRAM
(MADE UP OF CARS AND CDRS)
WHICH DOES THE JOB. SUCH FACILITIES MIGHT BE PW1, PUP, DAVID SHAW'S PGM, OR EVEN
TRIAL AND ERROR.)
WHY (TUPLE ONLY PART OF (@ LIST:STRUC)
IS DESIRED AT THIS POINT)
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS (TUPLE FUNCTION SUBROUTINE PROGRAM SYSTEM)
SPECIALIZATIONS (TUPLE CAR CDR ELEMENT:OF))
(PUTPROPS RECOGNIZE:EQUALITY BEING T
IDEN (((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T)))))
(PUTPROPS RECOGNIZE:LITERALS BEING T
IDEN (((Z@ (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(PROGN (PRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT
(TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (RATOM)
(QUOTE (YES Y PROBABLY)))))
(OR (SET ANY1 ANY1)
T)))
ANY1)))
(PUTPROPS RECOGNIZE:CAR BEING T
IDEN (((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(CDR (TRANSLATE (LIST VECTOR ANY1)
T))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T))))))))
(PUTPROPS ADD:DEFINITION BEING T
IDEN (((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T))))
EXPLICIT:ARGS (OBJECT DEFINITION)
EXPLICIT:ARGS:CHECK (ATOM OBJECT)
WHAT (TUPLE ADD THE DEFINITION OF (@ OBJECT)
AS
(@ DEFINITION)
TO PUP'S KNOWLEDGE)
HOW (TUPLE TRIVIALLY, ADD THE DEFN. TO EXISTING DEFNS.)
WHY (TUPLE THE OBJECT (@ OBJECT)
HAS BEEN REFERENCED, AND PUP FEELS UNCOMFORTABLE DISCUSSING ENTITIES IT CAN'T
DEFINE)
META:CODE (PROGN (SETQ ENCODABLE:SECTION:LIST (CONS OBJECT ENCODABLE:SECTION:LIST))
(SETQ TYPE:OF:LIST (MAPCAR TYPE:OF:LIST (FUNCTION
(LAMBDA (TOL)
(COND ((MATCH (VECTOR (@ OBJECT)
TYPE OF ANY1 IS
FRAG1 USED IN
ANY2)
TOL)
(VECTOR (@ OBJECT)
TYPE OF (@ ANY1)
IS
(@ DEFINITION)
AND IS USED IN
(@ ANY2)))
(T TOL))))))
(SETQ IS:DEFINED:LIST (NCONC1 IS:DEFINED:LIST (VECTOR (@ OBJECT)
IS
(@ DEFINITION)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
NON:EVAL:ARGS T)
(PUTPROPS ADJECTIVE:HANDLER BEING T
IDEN (((MATCH (TUPLE A DESCRIPTION OF A FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T))))))
IMPLICIT:ARGS (TNAME BNAME CODE TCODE MCODE)
EXPLICIT:ARGS (ADJ NOUN:GROUP)
EXPLICIT:ARGS:CHECK (MEMBER ADJ ADJECTIVES)
WHAT (TUPLE HANDLE THE ADJECTIVE (@ ADJ)
MODIFYING THE NOUN GROUP (@ NOUN:GROUP))
HOW (TUPLE LOOK AT (@ NOUN:GROUP)
AND SELECT THOSE PARTS WHICH ARE NOT CONTRADICTED BY THE ADJECTIVE
(@ ADJ))
WHY (TUPLE BECAUSE THE (@ ADJ)
PARTS OF (@ NOUN:GROUP)
ARE WANTED, AND THE (OPPOSITE ADJ)
PARTS ARE UNWANTED)
META:CODE (PROGN (SETQ FARGS NIL)
(SETQ BNAME (CAR (LAST NOUN:GROUP)))
(SETQ MCODE (GETP BNAME META:CODE))
(SETQ CODE (COND ((SETQ TCODE (SASSOC (OPPOSITE ADJ)
MCODE))
(PROCEDURE:PULLOUT TCODE MCODE))
((SETQ TCODE (SASSOC ADJ MCODE))
(CONS (CAR MCODE)
(CDR TCODE)))
(T MCODE))))
PRE:REQUISITES ((VECTOR NAMED EXPRESSION (INVECTOR (OUTTUPLE (CONS ADJ NOUN:GROUP)))
(SETQQ TNAME TNAME)))
POST:REQUISITES ((VECTOR IS BEING (@ TNAME)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
COMMENTS ((SET TNAME TNAME)))
(PUTPROPS ANALYZE:IMPLICATIONS IDEN (((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS OF SOME OF THE NEW INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS OF THE NEW INFO AND STUDYING THEM)
WHY (TUPLE TO IMPROVE THE UNDERSTANDING THAT PUP HAS OF THE NEW INFORMATION
(@ NEW:INFO))
WHEN (((SETQ ANY1 (CAR USABLE:INFO:LIST))
-60
(TUPLE BECAUSE WE SHOULD USE (@ ANY1)
BEFORE WORRYING ABOUT (@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO))
(TUPLE BECAUSE THE SIZE OF THE NEW INFORMATION (@ NEW:INFO)
AFFECTS HOW EASILY AND FRUITFULLY AN ANALYSIS OF IT WILL BE)))
META:CODE (PROGN (LOCATE:AFFECTED:AREA NEW:INFO)
(PREDICT:AFFECT NEW:INFO)
(EVALUATE:AFFECT NEW:INFO))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO RELEVANT:INFO:LIST)
MAIN:EFFECTS (((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1))))
AFFECTS (QUOTE ((LOCATE AFFECTED:AREA CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT CALLED)))
COMPLEXITY:VECTOR (.4 .7 .7 .5))
(PUTPROPS ASK:USER:ABOUT BEING T
IMPLICIT:ARGS (DTYPE IN:SET IN:SET:TRANS)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ASK THE USER TO RESOLVE DECISION (@ D))
HOW (TUPLE ASK THE USER WHAT THE RESOLUTION IS)
WHY (TUPLE BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
META:CODE (PROGN (TERPRI)
(SETQ DTYPE (CADADR D))
(PRIN1 "PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS ")
(PRIN1 DTYPE)
(PRIN1 " DECISION:")
(PRIN1 (CDAR (CDDADR D)))
(EVAL (EVAL (COLON:BACK (LIST DTYPE (CADR BEING:STACK)
KNOWLEDGE)))))
COMPLEXITY:VECTOR (.6 .6 .6 .6))
(PUTPROPS BETTER IDEN (((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T))))
BEING T
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF (@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF (@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
META:CODE (PROGN (SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW (CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW (CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE (WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
(COND ((EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER (CAR B1NEW)
(CAR B2NEW)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PARTS OF (@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
(@ (COND (RESULT1 (QUOTE LESS))
(T (QUOTE MORE))))
COMPLEX THAN THE LATTER BEING))))
(T (SETQ RESULT1 (NOT (MINUSP WHEN:DIFF)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1 SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW)))))))
RESULT1)
EXPLICIT:ARGS:CHECK (AND (EQUAL T (GETP (CAR B1)
BEING))
(EQUAL T (GETP (CAR B2)
BEING)))
PREDICATE T
COMPLEXITY:VECTOR NIL)
(PUTPROPS CHOOSE:FROM IDEN (((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T)))))))
BEING T
IMPLICIT:ARGS (EXP:TEST)
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET (@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
META:CODE (PROG (BEST)
(SETQ BEST (CAR S))
(SETQ BECAUSE (VECTOR WE MUST SELECT THE BEST BEING FROM
(INVECTOR (MAPCAR S (QUOTE CAR)))))
(COND ((SINGLETON S)
(SETQ BECAUSE (APPEND BECAUSE (VECTOR AND, TRIVIALLY,
(INVECTOR (CAR S))
IS OUR ONLY CHOICE))))
(T (MAPC (CDR S)
(FUNCTION (LAMBDA (S1)
(COND ((EQUAL T (BETTER S1 BEST))
(SETQ BEST S1))))))))
(SETQ BECAUSE (VECTOR NOW THAT WE HAVE SELECTED (CAR BEST)
AS THE BEST BEING OUT OF THE SET (MAPCAR S (QUOTE CAR))
WE MUST CARRY OUT (INVECTOR BEST)))
(COND ((SETQ TEMPBB (EVAL BEST))
(SETQ UNKNOWN:TASK TEMPBB))
((CDR S)
(CHOOSE:FROM (PULLOUT BEST S)))))
EXPLICIT:ARGS:CHECK (PROGN (SETQ EXP:TEST T)
(MAPC S (FUNCTION (LAMBDA (S1)
(COND ((NOT (EQUAL T (GETP (CAR S1)
BEING)))
(SETQ EXP:TEST NIL))))))
(COND (EXP:TEST)
(T (PRIN1 (VECTOR WARNING, WARNING; NOT ALL OF
(MAPCAR S (QUOTE CAR))
ARE BEINGS)))))
COMPLEXITY:VECTOR (.2 .4 .6 .5))
(PUTPROPS CLASSIFICATORY:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN HOW TO DISTINGUISH NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION OF THE DOMAIN OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN))
COMPLEXITY:VECTOR NIL)
(PUTPROPS COMPARITIVE:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN TO DISTINGUISH AND RANK NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION AND AN ORDERING OF THE RESULTANT
SUBSETS OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION))
COMPLEXITY:VECTOR NIL)
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION)))
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT STRUCTURING UPON A DOMAIN; LEARN HOW TO
CHARACTERIZE, OR AT LEAST DISTINGUISH, VARIOUS CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE OF CONCEPT FORMATION CALLED FOR, AND THEN
CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY TO CONCEPT KNOWLEDGE)
WHEN (((MEMBER TYPE:OF:C:F ABLE:PUP:LIST)
-70
(TUPLE BECAUSE IF WE CAN ALREADY DO (@ TYPE:OF:C:F)
THEN WE SHOULDNT TRY TO DO IT OVER AGAIN))
((MEMBER (QUOTE (CHARACTERIZE CLASSES))
PUP:WANTS:LIST)
88
(QUOTE (BECAUSE CONCEPT FORMATION IS A GOOD WAY TO GET A CHARACTERIZATION OF
CLASSES)))
(T (COND (NEW:INFO:LIST -60)
(T 40))
(QUOTE (BECAUSE NEW INFORMATION MIGHT ALTER OUR COURSE OF ACTION))))
META:CODE (EVAL (LIST TYPE:OF:C:F))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WORK ON CONCEPT FORMATION))
(VECTOR TYPE OF CONCEPT:FORMATION IS TYPE:OF:C:F)
(VECTOR AWARE USER
(VECTOR THE TYPE OF CONCEPT FORMATION PUP IS ABOUT TO WORK ON IS
(@ TYPE:OF:C:F))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP HAS THOUGHT ABOUT THE (@ TYPE:OF:C:F)
TYPE OF CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE INFERENCE:DEMONS ATTENTION:DEMONS)
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION)))
AFFECTS (TUPLE (TUPLE (EVAL TYPE:OF:C:F)
CALLED))
COMPLEXITY:VECTOR (.1 .5 .5 .5)
GENERALIZATIONS (ATTEND LEARN INDUCTIVE:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR ALTERNATIVES (VECTOR CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION
METRICAL:CONCEPT:FORMATION)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR CONCEPTS MAY VARY WITH TIME)
AFFECTS
(VECTOR THE BASIC STRUCTURE OF FORMING A CONCEPT)
CONCEPT:FORMATION)
(VECTOR BOOLEAN
(VECTOR CONCEPT FORMATION MAY DEPEND UPON THE SPEED OF
PRESENTATION OF THE STIMULI)
AFFECTS
(VECTOR THE AMOUNT OF EFFORT (@ TASK:NAME)
SHOULD SPEND ON IDENTIFYING EACH STIMULUS)
CONCEPT:FORMATION)
(VECTOR DICHOTOMY
(VECTOR (VECTOR INSTANCES MAY BE LEFT IN VIEW
INDEFINITELY)
(VECTOR INSTANCES MAY BE REMOVED AFTER PROCESSING)
)
RESULTS
(VECTOR (VECTOR NEW RELATIONS CAN BE DERIVED AS NEEDED)
(VECTOR ALL RELATIONS MUST BE DERIVED UPON
INITIAL EXPOSURE TO THE STIMULUS))
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO GET RELATIONS FROM
INPUT STIMULI)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR CONJUNCTIVE:CONCEPT:FORMATION
DISJUNCTIVE:CONCEPT:FORMATION
MIXED:CONJUNCTIVE:AND:DISJUNCTIVE:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW (@ TASK:NAME)
STORES THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:TRANSFER:CONCEPT:FORMATION
NEGATIVE:TRANSFER:CONCEPT:FORMATION
NO:TRANSFER:CONCEPT:FORMATION
POSITIVE:AND:NEGATIVE:TRANSFER:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW PREVIOUSLY:LEARNED CONCEPTS AND
PREVIOUSLY:ENCOUNTERED STIMULI AFFECT THE
LEARNING OF NEW CONCEPTS AND THE RECOGNITION THAT
A NEW CONCEPT IS NEW)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO SEARCH THROUGH THE
SET OF CONCEPTS)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:INSTANCE:UTILIZATION
NEGATIVE:INSTANCE:UTILIZATION
POSITIVE:AND:NEGATIVE:INSTANCE:UTILIZATION)
AFFECTS
(VECTOR WHAT INFORMATION (@ TASK:NAME)
MAY USE TO MODIFY THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
OF (@ TASK:NAME))
AFFECTS
(VECTOR WHETHER PARAMETERS DESCRIBING AN INDIVIDUAL MUST
BE READ IN BY (@ TASK:NAME))
WHEN
(VECTOR BEFORE ANY ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE ANY PROCESSING ROUTINE MAY HAVE TO DEPEND
UPON SOME INDIVIDUAL PARAMETERS)
CONCEPT:FORMATION)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN (@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
CONCEPT:FORMATION))
ALTERNATIVES ((GRAMMATICAL:INFERENCE PATTERN:RECOGNITION SIMULATED:EVOLUTION))
LIST (NIL . #7000))
(PUTPROPS DEFER:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1))))
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (MEMBER D UNDEFERRED:DECISION:LIST)
WHAT (TUPLE DEFER THE DECISION (@ D)
AS LONG AS POSSIBLE)
HOW (TUPLE DECIDE WHEN THE CONSEQUENCES OF DECISION (@ D)
WOULD NEXT AFFECT OUR WRITING THE PROGRAM CODE, AND THEN DEMONIZE THAT SITUATION)
WHY (TUPLE THE LONGER WE CAN DEFER ANY DECISION, INCLUDING (@ D)
,THE GREATER THE CHANCES THAT WE WILL HAVE GAINED ENOUGH NEW KNOWLEDGE OF THE
TASK THAT WHEN WE MUST FINALLY CONSIDER (@ D)
WE WILL KNOW ENOUGH TO ANSWER IT EASILY)
MAIN:EFFECTS (((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1))))
WHEN ((UNDEFERRED:DECISION:LIST 40
(VECTOR BECAUSE THERE EXIST UNDEFERRED DECISIONS, SO WE MUST
LOOK AFTER THEM IN SOME WAY BEFORE PROCEDING))
((MEMBER D UNDEFERRED:DECISION:LIST)
89
(VECTOR BECAUSE (@ D)
IS ONE OF THOSE UNDEFERRED DECISIONS)))
META:CODE (PROGN (SETQ UNDEFERRED:DECISION:LIST (PULLOUT D UNDEFERRED:DECISION:LIST))
(SETQ SITU (WHEN:NEXT (VECTOR PUP REINVESTIGATE (@ D))))
(COND ((EQUAL (CAR SITU)
VECTOR)
(SETQ SITU (CDR SITU))))
(COND ((EVAL SITU)
(RESOLVE:DECISION (VECTOR (@ D)
SINCE
(@ SITU))))
((EQUAL SITU (LIST FOREVER))
T)
(T (SETQ DEFERRED:DECISION:LIST (CONS (VECTOR (@ D)
UNTIL
(@ SITU))
DEFERRED:DECISION:LIST)))))
AFFECTS (QUOTE ((WHEN:NEXT CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS ELEMENT BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A STRUCTURE WHICH IS A MEMBER OF A LARGER STRUCTURE)
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION (VECTOR WHAT IS AN ELEMENT)
AFFECTS
(VECTOR CODE INVOLVING ELEMENT)
ELEMENT))
COMPLEXITY:VECTOR (.3 .3 .3 .3)
IDEN (((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT)))
DATA:STRUCTURE T)
(PUTPROPS ENCODE BEING T
IDEN (((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI)))
IMPLICIT:ARGS (FNAME FDESC F1 CODE FARGS YY ORIG:FUNC)
EXPLICIT:ARGS (FUNC)
EXPLICIT:ARGS:CHECK (PROGN
(SETQ ORIG:FUNC FUNC)
(AND (OR (AND (MATCH (VECTOR (VECTOR FRAG1)
NAME ANY1 FRAG2 ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2)
(SETQ F1 (CADR FDESC)))
(COND ((ATOM FUNC)
NIL)
(T (SETQ FUNC (CADR FUNC))
NIL))
(AND (MEMBER T (MAPCAR (REVERSE TYPE:OF:LIST)
(FUNCTION
(LAMBDA
(TT)
(COND
((EQUAL (CADR TT)
FUNC)
(SETQ F1 (SETQ FDESC
(CADDDR (CDDDR TT))))
(SETQ FNAME FUNC)
(SETQ
BNAME
(CAR (OUTVECTOR (CADDR (CDDR TT)))))
T))))))
(COND ((NULL F1)
(SETQ F1 FNAME)
(SETQ TYPE:OF:LIST (NCONC1 TYPE:OF:LIST
(VECTOR (@ F1)
IS
(SUBPAIR (GETP BNAME
EXPLICIT:ARGS)
(CDR FUNC)
(GETP BNAME
META:CODE)
T)))))
((MEMBER (VECTOR (@ FUNC)
TYPE OF (LIST VECTOR BNAME))
ENCODABLE:SECTION:LIST))
((MEMBER FUNC ENCODABLE:SECTION:LIST)))))
(OR (SATISFY (VECTOR ENCODABLE SECTION ORIG:FUNC))
(SATISFY (VECTOR ENCODABLE SECTION FUNC)))))
WHAT (VECTOR ENCODE A FUNCTION NAMED (@ FNAME)
TO ACCOMPLISH (@ BNAME)
BY USING, AMONG OTHER FACTS, (@ FDESC))
HOW (VECTOR DEFINE (@ FNAME)
USING
(@ FDESC))
WHY (VECTOR (@ FNAME)
IS CURRENTLY UNDEFINED)
META:CODE (PROGN (MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (PC)
(COND ((MATCH (VECTOR (@ F1)
IS FRAG1)
PC)
(SETQ CODE FRAG1))))))
(COND ((NULL CODE)
(PRIN1 (CONCAT "
PUP IS NOW GOING TO ENCODE THE PIECE " (OUTVECTOR F1)
" OF THE FUNCTION " FNAME
" INTO LISP. FUNCTION NAMES WILL BE QUERIED IN PRE-ORDER, AS REQUIRED.
"))
(SETQ CODE (GETCODE (OUTVECTOR F1)
FNAME 1)))
(T (SETQ FARGS (APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(SETDIFFERENCE (OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST PUP5FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST IS:BEING:LIST
SET:OF:BEING:PARTS PUP5VARS))))))
(SETQ FARGS (INTERSECTION FARGS FARGS))
(EVAL (LIST (QUOTE DEFINEQ)
(LIST FNAME (LIST (COND ((GETP BNAME NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA)))
(COND (FARGS)
(T NIL))
CODE))))
(PRIN1 "
PUP NOW DEFINES THIS FUNCTION:
")
(PRETTYPRINT (LIST FNAME))
(LIST (VECTOR WE DEFINE THE FUNCTION (@ FNAME)
AS:
(INVECTOR CODE))))
POST:REQUISITES ((VECTOR IS BEING FNAME))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN (((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL NUCLEUS OF RELEVANT INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE IRRELEVANT INFO FROM (@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF INFO IS RELEVANT TO ANY SPECIFIC PROBLEM, AND PUP
CANNOT HANDLE A LARGE MASS OF INFO EFFICIENTLY)
WHEN (((GREATERP (SIZE NEW:INFO)
50)
70
(QUOTE (BECAUSE IF THE NEW INFO IS OVER 50 TOKENS LONG, THEN WE CANNOT
EFFICIENTLY COMPREHEND IT)))
((LESSP (SIZE NEW:INFO)
12)
-80
(QUOTE (BECAUSE IF THE NEW INFO IS LESS THAN A DOZEN TOKENS LONG THEN WE
SHOULD EASILY BE ABLE TO PROCESS IT AS IT IS))))
META:CODE (PROGN (USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(VECTOR RELEVANT NEW:INFO))
(SETQ RELEVANT:INFO:LIST (CONS NEW:INFO RELEVANT:INFO:LIST)))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO NEW:INFO:LIST)
MAIN:EFFECTS (((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1))))
AFFECTS (QUOTE ((APPLY:PROGRAMMING:KNOWLEDGE CALLED)))
COMPLEXITY:VECTOR (.3 .6 .6 .5))
(PUTPROPS FILL:IN:UNDEFINED:SECTION BEING T
IDEN (((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI))))
IMPLICIT:ARGS (CHOICE)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK UNDEFINED:SECTION:LIST
WHAT (VECTOR FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM
(@ PROGRAM))
HOW (VECTOR CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
WHY (VECTOR BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
WHEN ((UNDEFINED:SECTION:LIST 80
(TUPLE BECAUSE UNDEFINED:SECTION:LIST CONTAINS
PIECES OF CODE AS YET UNDEFINED))
((NULL UNDEFINED:SECTION:LIST)
-1000
(TUPLE BECAUSE NO PIECES OF CODE ARE KNOWN AND YET NOT YET DEFINED))
((SETINTERSECTION ENCODABLE:SECTION:LIST UNDEFINED:SECTION:LIST)
96
(TUPLE BECAUSE WE KNOW ENOUGH TO CODE EACH OF THE FOLLOWING SECTIONS:
(INVECTOR (SETINTERSECTION UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST)))))
META:CODE (COND ((SETQ NEW:PIECE (ENCODE CHOICE))
(SETQ UNDEFINED:SECTION:LIST (PULLOUT CHOICE
UNDEFINED:SECTION:LIST))
(COND ((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ UNDEFINED:SECTION:LIST (PULLOUT (LIST VECTOR ANY2)
UNDEFINED:SECTION:LIST))))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT CHOICE
ENCODABLE:SECTION:LIST))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SET PROGRAM (APPEND (EVAL PROGRAM)
NEW:PIECE)))
(T (SETQ DOING:PUP:LIST (CDDR DOING:PUP:LIST))
(SETQ PUP:WANTS:LIST (CONS (VECTOR MORE INFO RELEVANT TO
MAKING (@ CHOICE)
CODABLE)
PUP:WANTS:LIST))
NIL))
COMMENTS ((SETQ CHOICE (INVECTOR (MINIMUM (COND ((SETINTERSECTION
UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST))
(T UNDEFINED:SECTION:LIST))
FAST:BEING:COMPLEX)))
(SETQ DOING:PUP:LIST (CONS CHOICE DOING:PUP:LIST))
(SATISFY
(VECTOR
TYPE OF
(VECTOR
(VECTOR (PROG1 (COND ((ATOM CHOICE)
(SETQ TC CHOICE))
((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ TC ANY1)
ANY2)
(T (SETQ TC (CAR (OUTVECTOR CHOICE)))))
(SETQ DOING:PUP:LIST
(CONS (INVECTOR (SASSOC TC (OUTVECTOR
FN:CALL:LIST)))
DOING:PUP:LIST))
(MAPC (CDR (SASSOC TC (OUTVECTOR FN:CALL:LIST)))
(FUNCTION
(LAMBDA
(AA)
(COND
((ATOM AA)
(SATISFY (VECTOR TYPE OF
(VECTOR
(LIST VECTOR AA)
HAS BEEN STUDIED)))
)))))))
HAS BEEN STUDIED))
T))
AFFECTS (QUOTE ((ENCODE CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS GET:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE GET (@ ENTITY)
INTO PUP'S AWARENESS)
HOW (TUPLE SEE IF (@ ENTITY)
IS ALREADY KNOWN; IF NOT, TRY TO COMPUTE IT; IF THIS ALSO FAILS, ASK THE USER ABOUT
IT)
WHY (TUPLE PUP NEEDS (@ ENTITY)
AT THIS POINT IN TIME)
META:CODE (OR (TAKE:HOLD:OF ENTITY)
(ASK:USER:ABOUT ENTITY))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
NLAMBDA T)
(PUTPROPS GET:NAME BEING T
IDEN (((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI))))
IMPLICIT:ARGS (TEMP1 NE EV:NEW:NAME)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER TO (@ EXPRESSION))
WHEN ((T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE NO MORE AND NO LESS THAN ONE NAME))))
META:CODE (COND ((NUMBERP (CAR (LAST (COLON:BREAK EV:NEW:NAME))))
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))
(T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
(TERPRI)
(PRIN1 (CONCAT "IS THIS THE SAME AS A " EXPRESSION
" WHICH WE'VE ALREADY SEEN AND NAMED?
USER: "))
(SETQ TEMP1 (MEMBER (READ)
(QUOTE (Y YES MAYBE))))))
(COND (TEMP1 (SETQ NE (INTERSECTION (SETQ
TEMPINT
(MAPCONC
TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF
(@ EXPRESSION)
FRAG1)
TOL)
(LIST ANY1)))))))
TEMPINT))))
(COND ((CDR NE)
(PRIN1 (CONCAT NE
" ARE SUCH NAMES. SINCE THERE IS MORE THAN ONE, PLEASE TYPE IN TO ME THE NAME (AGAIN) OF ONE OF THE ABOVE,
OR TYPE <CR> IF THE NAME YOU WANT ISNT REALLY ONE OF THESE AFTER ALL.
USER: "))
(SETQ TEMP1 (READ)))
(NE (PRIN1 (CONCAT "SINCE " (CAR NE)
" IS THE ONLY NAME FOR " EXPRESSION
",
AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
YOU WANT. AM I RIGHT?
USER: "))
(SETQ TEMP1 (COND ((MEMBER (READ)
(QUOTE (Y YES)))
(CAR NE)))))
(T (PRIN1 (CONCAT "I DON'T KNOW ANY NAMES FOR " EXPRESSION
", SO YOU'LL HAVE TO
TYPE A BRAND NEW NAME IN TO ME. "))
(TERPRI)
(SETQ TEMP1 NIL)))
(COND (TEMP1 (SETQ OLDNAME:TAG T)
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TEMP1))
(T (PRIN1 "USER: ")
(SETQ TREAD (READ))
(SETQ TREAD (COND (TREAD)
((COLON:BACK (OUTVECTOR (OUTNIL (FLATTEN EXPRESSION))
)))))
(COND ((NOT (OR (MEMBER TREAD PRIMITIVE:PROGRAMS:LIST)
(NUMBERP (CAR (LAST (COLON:BREAK TREAD))))))
(SETQ TREAD (PACK (TUPLE (@ TREAD)
:
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER))
)))))
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TREAD)
(SET TREAD TREAD)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))))
)
COMMENTS ((COND ((NOT (ATOM NEW:NAME))
(SETQ NEW:NAME (CADR NEW:NAME)))
(T T))
(SETQ EV:NEW:NAME (COND ((ATOM NEW:NAME)
NEW:NAME)
(T (EVAL NEW:NAME)))))
PRE:REQUISITES ((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR (@ EXPRESSION)))
(VECTOR AWARE USER (VECTOR PUP WANTS USER TO TYPE IN NAME FOR (@ EXPRESSION))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP AND USER ARE ABLE TO REFER TO (@ EXPRESSION)
AS
(@ NEW:NAME)
WHICH IS (EVAL NEW:NAME))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2))))
COMPLEXITY:VECTOR (.1 .3 .2 .5))
(PUTPROPS GET:NEW:INFORMATION IDEN (((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF INFORMATION AND CALL IT (@ NEW:INFO))
HOW (TUPLE ASK THE USER FOR NEW INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE ESPECIALLY SPEC:WHY)
WHEN ((T (COND (NEW:INFO:LIST -68)
(T 50))
(QUOTE (BECAUSE WE SHOULD GET NEW INFORMATION IFF THERE IS NONE IN EXISTENCE)))
)
META:CODE (PROG1 (COND ((ATOM NEW:INFO)
(SET NEW:INFO (INVECTOR (READ))))
(T (SET (EVAL NEW:INFO)
(INVECTOR (READ)))))
(SETQ NEW:INFO:LIST (CONS (EVAL NEW:INFO)
NEW:INFO:LIST))
(SETQ PUP:WANTED:LIST (CONS (CAR PUP:WANTS:LIST)
PUP:WANTED:LIST))
(SETQ PUP:WANTS:LIST (CDR PUP:WANTS:LIST)))
COMMENTS ((PRIN1 "
USER: ")) PRE:REQUISITES ((VECTOR AWARE USER (APPEND (QUOTE (VECTOR PUP WANTS))
(CDAR PUP:WANTS:LIST))))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1))))
COMPLEXITY:VECTOR (.1 .1 .1 .5))
(PUTPROPS IS:OF:TYPE BEING T
EXPLICIT:ARGS (OBJECT SPECIAL:KNOWLEDGE)
EXPLICIT:ARGS:CHECK (MATCH (TUPLE COMMENT FRAG1)
SPECIAL:KNOWLEDGE)
WHAT (TUPLE SEE IF (@ OBJECT)
IS OF THE TYPE SPECIFIED. THE PARTICULAR TYPE IS DELINEATED BY THE SPECIAL KNOWLEDGE
(@ SPECIAL:KNOWLEDGE))
HOW (TUPLE USE (@ SPECIAL:KNOWLEDGE)
DETAILS TO SEE IF IT CONTAINS (@ OBJECT))
WHY (TUPLE WE MUST BE ABLE TO TEST AN OBJECT (@ OBJECT)
AND SEE IF IT BELONGS TO THE TYPE (@ SPECIAL:KNOWLEDGE))
META:CODE (PROGN (ASK:USER:ABOUT OBJECT))
COMPLEXITY:VECTOR (.35 .35 .35 .35)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION
(VECTOR HOW DO WE KNOW WHEN THE 'IS:OF:TYPE' PREDICATE IS TRUE,
AND WHEN IT IS FALSE? PUP ASSUMES THAT USER WILL TYPE IN
A LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT TO IT)
AFFECTS
(VECTOR CODE INVOLVING IS:OF:TYPE)
IS:OF:TYPE)))
(PUTPROPS MAKE:ENCODABLE BEING T
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR TRY TO MAKE (@ B:CALL)
ENCODABLE)
HOW (TUPLE FIRST SEE IF IT ALREADY IS; IF NOT, TRY TO USE DOMAIN:DEPENDENT KNOWLEDGE)
WHY (TUPLE BECAUSE (@ B:CALL)
MUST EVENTUALLY GET ENCODED)
MAIN:EFFECTS (((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1))))
META:CODE (OR (AND (ATOM B:CALL)
(GETP B:CALL ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
TYPE OF (CAR (GETP B:CALL
GENERALIZATIONS))
IS
(INVECTOR (GETP B:CALL META:CODE)))
TYPE:OF:LIST)))
(AND (MATCH (VECTOR ANY1 TYPE OF ANY2 FRAG1)
B:CALL)
(SETQ ANY1:HOLD ANY1)
(SETQ ANY2:HOLD ANY2)
(COND ((MAKE:ENCODABLE ANY1))
((GETP ANY2:HOLD ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ ANY1:HOLD)
TYPE OF (@ ANY2:HOLD)
IS
(INVECTOR (GETP ANY2:HOLD
META:CODE)))))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS MAKE:NEW:BEING BEING T
EXPLICIT:ARGS (FNAME)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR GIVE BIRTH TO THE NEW BEING (@ FNAME))
HOW (VECTOR FILL IN EACH PART OF A BEING, FOR THE BEING (@ FNAME))
WHY (VECTOR (@ FNAME)
MUST EXIST TO BE UNDERSTOOD)
MAIN:EFFECTS (((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1))))
META:CODE (PROGN (SET FNAME FNAME)
(SETQ YY WRITE:PROGRAM)
(SETQ IS:BEING:LIST (CONS FNAME IS:BEING:LIST))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (BP)
(COND ((GETP BNAME BP)
(PUT FNAME BP
(GETP BNAME BP)))))))
(PUT FNAME BEING T)
(PUT FNAME IDEN (SUBST FNAME BNAME (COPY (GETP FNAME IDEN))))
(ADD:IDEN FNAME)
(PUT FNAME MAIN:EFFECTS (SUBST FNAME BNAME (COPY (GETP FNAME MAIN:EFFECTS)))
)
(ADD:EFFECTS FNAME)
(PUT FNAME EXPLICIT:ARGS (SETUNION FARGS (GETP BNAME EXPLICIT:ARGS)))
(PUT FNAME WHAT (VECTOR A SPECIALIZED BEING WHICH DOES (GETP BNAME WHAT)))
(PUT FNAME WHY (APPEND (GETP FNAME WHY)
(TUPLE AND (@ BNAME)
IS TOO GENERAL TO USE AS IT IS)))
(PUT FNAME META:CODE CODE)
(PUT FNAME GENERALIZATIONS (CONS BNAME (GETP FNAME GENERALIZATIONS)))
(PUT FNAME AFFECTS (PROG (X)
(SETQ X (VECTOR))
(MAPC (FLATTEN CODE)
(FUNCTION
(LAMBDA (CC)
(COND
((GETP (CAR (COLON:BREAK CC))
BEING)
(SETQ
X
(NCONC1 X
(VECTOR (@ CC)
POSSIBLE
CALLED)))
(SETQ YY (CONS CC YY)))))))
(RETURN X)))
(PUT FNAME SPECIALIZATIONS NIL)
(PUT FNAME COMPLEXITY:VECTOR (VECTOR:AVERAGE YY))
(SEMI:COMPILE FNAME)
T)
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS MESSAGE IDEN (((AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2))
(VECTOR MESSAGE (CADR LI)))
((MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI)
(VECTOR MESSAGE (INVECTOR FRAG1))))
BEING T
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL READ THE MESSAGE (@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE INFORMATION IN THE MESSAGE (@ M))
WHEN (((MEMBER M AWARE:USER:LIST)
-201
(QUOTE (BECAUSE THE USER NEVER FORGETS))))
META:CODE (PROGN (TERPRI)
(PRIN1 "PUP: ")
(PRINT (OUTVECTOR M))
(TERPRI)
(SETQ AWARE:USER:LIST (CONS M AWARE:USER:LIST))
(SETQ FRINGE:CONCIOUS:LIST (LIST M (CAR FRINGE:CONCIOUS:LIST)))
(SETQ LASTRESPONDER (QUOTE PUP))
(SETQ READ:USER:LIST (CONS M READ:USER:LIST)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR READ USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1))))
MINOR:EFFECTS ((QUOTE (LASTRESPONDER PUP)))
COMPLEXITY:VECTOR (0.0 .1 .9 .7)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY))
(PUTPROPS METRICAL:CONCEPT:FORMATION BEING T
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION)
(METRIZE ORDER))
COMPLEXITY:VECTOR NIL)
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN (((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME INFORMATION WHICH CAN BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT OLD INFORMATION, OR OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE INFORMATION THAT IT CAN USE TO PROGRESS)
WHEN ((T -10 (TUPLE SINCE THIS IS AN EXPONENTIALLY-GROWING, BAD THING TO DO IN
GENERAL))
(NEW:INFO:LIST 111
(QUOTE (BECAUSE WE SHOULD WORK ON UNASSIMILATED NEW
INFORMATION IF THERE IS ANY))))
META:CODE (PROGN (SETQ BECAUSE
(QUOTE (VECTOR WE CAN ONLY TRY TO OBTAIN USABLE
INFORMATION IN ONE WAY AT A TIME)))
(CHOOSE:FROM (QUOTE ((TRANSLATE U)
(GET:NEW:INFORMATION U)
(ANALYZE:IMPLICATIONS U)
(EXTRACT:RELEVANT:SUBSET U)))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1))))
AFFECTS (QUOTE ((CHOOSE:FROM CALLED)
(TRANSLATE POSSIBLE:CALLED)
(GET:NEW:INFORMATION POSSIBLE:CALLED)
(ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS PARTITION:A:DOMAIN BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (COMMENT WE SHOULD NEVER REALLY BE HERE, SINCE THIS IS ALWAYS DONE BY A
COLLECTION OF THE THREE METHODS OF PARTITIONING DISCUSSED IN
THE 'SPECIALIZATIONS' SECTION)
(SETQ PARTITIONED:DOMAIN:LIST T))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY PARTIAL)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
ZERO CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY WEAK)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
MANY CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR SOMEOF (VECTOR PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:GET:CLASS)
AFFECTS
(VECTOR THE PARTITION:A:DOMAIN ALGORITHM)
PARTITION:A:DOMAIN))
IDEN (((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN)))
WHAT (TUPLE DIVIDE A DOMAIN INTO SUBDOMAINS; USUALLY THESE WILL BE DISJOINT, AND THEIR
UNION WILL BE THE ENTIRE DOMAIN)
HOW (TUPLE BY BUILDING UP THE PARTITION GRADUALLY, BY ADDING TO OUR KNOWLEDGE OF THE
PARTITION ONE PAIR AT A TIME; HERE A PAIR IS <ELEMENT, CLASS:NAME>)
WHY (TUPLE BECAUSE PUP MUST ENCODE A FUNCTION WHICH PARTITIONS A DOMAIN INTO CLASSES)
MAIN:EFFECTS (((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN)))
WHEN ((PARTITIONED:DOMAIN:LIST -100 (TUPLE BECAUSE WE ALREADY HAVE PARTITIONED DOMAIN))
((NULL PARTITIONED:DOMAIN:LIST)
20
(TUPLE BECAUSE PUP HAS NOT YET PARTITIONED DOMAIN, SO IT IS PLAUSIBLE TO DO IT
NOW)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON)
GENERALIZATIONS (TUPLE MAP BUILD:FUNCTION)
ALTERNATIVES (TUPLE DIVIDE:UP DISCRETIZE))
(PUTPROPS PARTITION:BY:TAKE:CLASS:GET:ELE BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (TAKE:HOLD:OF NAME:OF:CLASS)
(GET:HOLD:OF ELEMENT))
GENERALIZATIONS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR NIL)
(PUTPROPS PARTITION:BY:TAKE:ELE:AND:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENTS AND THEIR
ASSOCIATED CLASS NAMES)
HOW (TUPLE READ IN PAIRS OF ELEMENT:CLASS)
WHY (TUPLE PARTITION IS DEFINED AS A SET OF ORDERED PAIRS)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(TAKE:HOLD:OF NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS PARTITION:BY:TAKE:ELE:GET:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENT AND
DETERMINING THE CLASS IT BELONGS TO)
HOW (TUPLE READ IN ELEMENT, DEDUCE ITS CLASS)
WHY (TUPLE TO SHOW THAT THE PARTITIONING IS BEING DONE CORRECTLY)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(GET:HOLD:OF NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN (((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI))))
IMPLICIT:ARGS (EXPRES2 NEW:EXPRES)
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK (COND ((ATOM EXPRES)
(SETQ NEW:EXPRES (COLON:BREAK EXPRES)))
(T (SETQ NEW:EXPRES
(PROG (TEMP1)
(MAPC EXPRES (FUNCTION
(LAMBDA (ZZ)
(SETQ TEMP1
(APPEND
TEMP1
(COLON:BREAK
ZZ))))))
(RETURN TEMP1)))))
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO EXTRACT MNEMONIC CONTRACTIONS OF (@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN CHOOSING A EXPRES FOR THE OBJECT (@ EXPRES))
MAIN:EFFECTS (((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1))))
WHEN ((T (COND ((MEMBER (TUPLE PLAUSIBLE NAMES FOR (@ EXPRES))
PUP:STUDIED:LIST)
-99)
(T 33))
(QUOTE (BECAUSE WE SHOULDNT WASTE TOO MUCH TIME GETTING PLAUSIBLE NAMES,
YET WE ALSO SHOULDNT COMPLETELY LET THE USER FEND FOR
HIMSELF ON THIS SUBJECT))))
META:CODE (PROG (P)
(SETQ EXPRES2 (OUTVECTOR (OUTQUOTE NEW:EXPRES)))
(SETQ P (MAPCAR (LIST (INITIALS EXPRES2)
(MAIN:WORDS EXPRES2)
(FIRST:FEW (INITIALS EXPRES2))
(FIRST:FEW (MAIN:WORDS EXPRES2))
(FIRST:FEW (INITIALS (MAIN:WORDS EXPRES2)))
(LIST (PACK (INITIALS EXPRES2)))
(LIST (PACK (FIRST:FEW (INITIALS EXPRES2)))))
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE P KNOWN:NAMES))
(SETQ P (INTERSECTION P P))
(SETQ MSG (VECTOR (@ P)
IS THE SET OF PLAUSIBLE NAMES OF (@ EXPRES2)
WHICH IS AN EXPANSION OF (@ EXPRES)))
(SETQ PLAUSIBLE:NAMES:LIST (CONS (VECTOR FOR (@ EXPRES)
HAVE BEEN STUDIED)
PLAUSIBLE:NAMES:LIST))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR PLAUSIBLE NAMES FOR
(@ EXPRES))
PUP:STUDIED:LIST))
(RETURN P))
POST:REQUISITES ((VECTOR AWARE USER (INVECTOR MSG)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON)
COMPLEXITY:VECTOR (.1 .2 .3 .5))
(PUTPROPS REINVESTIGATE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (OR (MEMBER D DEFERRED:DECISION:LIST)
(EQUAL (CADDDR D)
(VECTOR BECAUSE OF DIRECT COMMAND)))
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE; FIRST TRY TO DEFER IT A LITTLE LONGER)
HOW (VECTOR TRY TO DEFER (CADDR D)
;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;ELSE ASK THE USER TO
RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADDR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D)))))
META:CODE (PROGN (SETQ DEFERRED:DECISION:LIST (PULLOUT D DEFERRED:DECISION:LIST))
(SETQ UNDEFERRED:DECISION:LIST (CONS (CADR D)
UNDEFERRED:DECISION:LIST))
(DEFER:DECISION (CADR D)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS REPEATEDLY BEING T
EXPLICIT:ARGS (ACT1 ACT2 ACT3 ACT4)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE DO ACTIONS OVER AND OVER)
HOW (TUPLE CONVERT THE SINGLE FUNCTION CALL INTO AN INFINITE ITERATIVE LOOP)
WHY (TUPLE THIS IS EASIER, SURER, AND OFTEN FASTER THAN RECURSION)
META:CODE (PROGN (VECTOR SEE THE FORM:CHANGING SECTION)
(SETQ F1 (APPEND (TUPLE REPEATEDLY)
ACT1 ACT2 ACT3 ACT4))
(EVAL (GETP REPEATEDLY FORM:CHANGING)))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
FORM:CHANGING (PROGN (SETQ F1 (APPEND (TUPLE PROG NIL (SETQ TEMPL (COLON:BACK
(TUPLE LABEL (SETQ LABEL:COUNTER
(ADD1
LABEL:COUNTER)))))
)
(CONS (PROG1 (SETQ C1 (GETCODE (CADR F1)
FNAME 0))
(COND ((NUMBERP (CAR (LAST (COLON:BREAK
C1))))
(SETQ
FN:CALL:LIST
(CONS (INVECTOR (CONS C1
(CDDR F1)))
FN:CALL:LIST)))))
(GETCODE (CDDR F1)
FNAME 1))
(TUPLE (LIST GO TEMPL)
(TUPLE COMMENT INFINITE LOOP IN THIS PROG))))
(SETQ CODING:WARNING:LIST (CONS (VECTOR INFINITE LOOP IN (@ FNAME)
FROM
(@ TEMPL)
TO
(LIST VECTOR GO TEMPL))
CODING:WARNING:LIST))
F1))
(PUTPROPS RESOLVE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE)
HOW (VECTOR TRY TO RESOLVE (CADR D)
WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK THE USER ABOUT IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND)))))
META:CODE (COND ((MEMBER (CADR D)
RESOLVED:DECISION:LIST)
T)
(T (SETQ RESOLVED:DECISION:LIST (CONS (VECTOR (CADR D)
IS RESOLVED AS
(INVECTOR (ASK:USER:ABOUT
D)))
RESOLVED:DECISION:LIST))))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SATISFY IDEN (((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T))))
IMPLICIT:ARGS (TEMP:LIST)
EXPLICIT:ARGS (G FORCE:SAT)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL (@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
META:CODE (COND ((AND (MEMBER (EVAL (CADDDR G))
(EVAL (SETQ TEMP:LIST (COLON:BACK (COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST)))))))
(NOT FORCE:SAT)))
(T (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA (E1)
(COND
((MATCH (CAR E1)
G)
(SETQ B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(SETQ BECAUSE
(VECTOR WE CALL THE SIMPLEST BEING WHICH CAN BRING ABOUT THE EFFECT
(@ G)))
(COND (B:LIST (RETURN (PROG (CB:LIST)
(SETQ CB:LIST (COPY (MAPCAR B:LIST
(QUOTE CDR))))
(SETQ CB:LIST (INTERSECTION CB:LIST CB:LIST))
(SORT CB:LIST A:BEING:ORDER)
LABEL5
(SETQ POS:B (CAR CB:LIST))
(EVAL POS:B)
(COND ((MEMBER (EVAL (CADDDR G))
(EVAL TEMP:LIST))
(RETURN (SETQ PUP:SATISFIED:LIST
(CONS G
PUP:SATISFIED:LIST))))
((CDR CB:LIST)
(SETQ CB:LIST (CDR CB:LIST))
(GO LABEL5))
(T (PRIN1
"
WARNING: SATISFY IS SHAKING ITS HEAD ABOUT THIS ONE:")
(PRIN1 G)
(RETURN NIL))))))
(T (RETURN NIL))))))
COMMENTS ((SETQ G (EVAL G)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1))))
AFFECTS (APPEND (MAPCAR (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA
(E1)
(COND ((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(RETURN B:LIST))
(FUNCTION (LAMBDA (Y)
(COND (Y (CONS Y (QUOTE (POSSIBLE:CALLED))))))))
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED))))
COMPLEXITY:VECTOR (0.0 .3 .2 .4)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM ADAPT:PRECONCEIVED:FUNCTION)
BEING T
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SCENE BEING T
META:CODE (STRUCTURE (OBJECTS SET O)
(CLASS:NAME NAME N)
(STATIC RELATIONS S BETWEEN OBJECTS)
(DYNAMIC RELATIONS D BETWEEN OBJECTS))
IDEN (((EQUAL LI (LIST SCENE))
(VECTOR SCENE)))
COMPLEXITY:VECTOR NIL
DATA:STRUCTURE T)
(PUTPROPS SERVE IDEN (((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE)))
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
META:CODE (PROG (UNKNOWN:TASK)
(SETQ UNKNOWN:TASK NON:EXECUTABLE)
(SETQ BECAUSE (VECTOR THE CURRENT TASK (@ UNKNOWN:TASK)
IS NOT EXECUTABLE AND WE HAVE NOTHING ELSE TO DO AT THE PRESENT
TIME))
LABEL6
(COND ((NOT (MEMBER UNKNOWN:TASK EXECUTABLE:INFO:LIST))
(MAPC USER:INTERRUPT:DEMONS (QUOTE APPLY*))
(OBTAIN:USABLE:INFORMATION (QUOTE UNKNOWN:TASK))
(GO LABEL6)))
(SETQ ATTEMPTING:SOMETHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:SOMETHING:LIST))
(SETQ ATTEMPTING:ANYTHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:ANYTHING:LIST))
(SETQ BECAUSE (VECTOR WE FINALLY HAVE AN EXECUTABLE TO TASK TO DO, NAMELY
(@ UNKNOWN:TASK)))
(SETQ EXECUTABLE:INFO:LIST NIL)
(EVAL (CDR UNKNOWN:TASK)))
COMMENTS ((SETQ PUP:WANTS:LIST (CONS (VECTOR ANY TASK)
PUP:WANTS:LIST)))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WANTS ANY TASK)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE)))
COMPLEXITY:VECTOR (.2 .4 .6 .8)
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
DEMONS (TUPLE FORGETFUL:USER:DEMON))
(PUTPROPS STUDY:TYPE BEING T
IDEN (((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI))))
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK (GETP (CADR B:CALL)
BEING)
WHAT (TUPLE INVESTIGATE THE VARIOUS SPECIALIZATIONS OF (@ B:CALL))
HOW (TUPLE TRANSFER THE SPECIALIZATIONS (GETP (CADR B:CALL)
SPECIALIZATIONS)
OF
(@ B:CALL)
ONTO THE LIST OF DECISIONS WHICH MUST BE ATTENDED TO)
WHY (TUPLE BECAUSE THE MORE SPECIFIC OUR KNOWLEDGE OF WHAT IS WANTED, THE MORE EASILY AND
COMPLETELY WE MAY SATISFY THAT REQUEST)
MAIN:EFFECTS (((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1))))
META:CODE (PROGN (MAPC (CDR (GETP (CADR B:CALL)
SPECIALIZATIONS))
(FUNCTION (LAMBDA (A)
(SETQ UNDEFERRED:DECISION:LIST
(NCONC1 UNDEFERRED:DECISION:LIST
(COND ((ATOM A)
A)
((ATOM (CAR A))
(EVAL A))
((APPLY* (EVAL (CAR A))
B:CALL))))))))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR TYPE OF (@ B:CALL))
PUP:STUDIED:LIST))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
HAS BEEN STUDIED)
TYPE:OF:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS TAKE:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TAKE THE ENTITY (@ ENTITY)
IN A TRIVIAL WAY; EITHER BY ACCESSING IT OR BY READING IT IN)
HOW (TUPLE LOOK AROUND A LITTLE; IF IT ISNT FOUND TRIVIALLY, THEN ASK THE USER TO GIVE
(@ ENTITY)
TO US)
WHY (TUPLE PUP WANTS (@ ENTITY)
,AND WE DON'T HAVE TO DO ANY COMPUTING TO GET IT)
COMPLEXITY:VECTOR (.5 .5 .5 .5)
SPECIALIZATIONS (VECTOR
(VECTOR DICHOTOMY (QUOTE (AND (FLOW:PRECEDED (VECTOR SETQ (@ ARG1)
ANY1))
(PRINT (TUPLE THE ASSIGNMENT
(LIST (QUOTE SETQ)
ARG1 ANY1)
WAS DONE EARLIER; SHOULD A NEW
VALUE OF (@ ARG1)
BE READ IN AT THIS POINT IN THE
PROGRAM FLOW? USER...))
(MEMBER (READ)
(QUOTE (N NO NIL)))))
AFFECTS
(VECTOR THE TAKE:HOLD:OF ALGORITHM)
RESULTS
(VECTOR (COMMENT DO NOTHING SINCE WE ALREADY HAVE WHAT WE WANT)
(QUOTE (APPEND (VECTOR PROG1 (VECTOR SET ARG1 (TUPLE READ))
(COMMENT IN ALL CALLS TO DATE, ARG1
IS INSTANTIATED AS
(@ ARG1)))
(MAPCAR
(CDR (GETP (EVAL ARG1)
META:CODE))
(FUNCTION
(LAMBDA
(EPART)
(SETQQ NEWNAME NEWNAME)
(PRINT (TUPLE PUP IS ABOUT TO ENCODE AN
ASSIGNMENT: (@ EPART)
WILL BE SET TO SOME PART
OF ARG1 WHICH IS GOING TO
BE INSTANTIATED DURING
THE RUNNING OF THE
PROGRAM AS (EVAL ARG1)
.PUP WANTS A NAME FOR
THIS 'SOME PART OF'
FUNCTION.))
(GETCODE (TUPLE SETQ (COLON:BACK EPART)
(TUPLE SOME:PART:OF
ARG1))
(CAR (LAST (CADR D)))
-1))))
(LIST T))))
TAKE:HOLD:OF))
NLAMBDA T)
(PUTPROPS TRANSLATE IDEN (((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO FORCE:TRANSLATE)
WHAT (TUPLE TRANSLATE A PIECE OF UNTRANSLATED NEW INFORMATION)
HOW (TUPLE TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (TUPLE EW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE PROCEDURAL BEFORE IT MAY BE USED BY THE SYSTEM)
WHEN ((T (COND (USABLE:INFO:LIST -60)
(T 50))
(QUOTE (BECAUSE THE ABSENCE OF USABLE INFORMATION ABDUCTIVELY CALLS FOR ITS PRODUCTION;
ITS PRESENCE DEMANDS ITS ASSIMILATION)))
((MEMBER (EVAL NEW:INFO)
TRANSLATED:INFO:LIST)
-111
(VECTOR BECAUSE WE HAVE ALREADY TRANSLATED IT IMPLIES WE SHOULDNT NOW)))
META:CODE (PROG (LI TEMPTR)
(SETQ LI (CDR EV:NEW:INFO))
(SETQ NEW:INFO:LIST (PULLOUT EV:NEW:INFO NEW:INFO:LIST))
(MAPC IDEN:TABLE (FUNCTION (LAMBDA (II)
(COND ((EVAL (CAR II))
(COND ((SETQ TEMPTR
(EVAL (CADR II)))
(SETQ TRANSLATED:PAIR:LIST
(CONS (LIST EV:NEW:INFO
TEMPTR)
TRANSLATED:PAIR:LIST)
)
(SETQ TRANSLATED:INFO:LIST
(CONS EV:NEW:INFO
TRANSLATED:INFO:LIST))
(COND ((NOT FORCE:TRANSLATE)
(SETQ
EXECUTABLE:INFO:LIST
(CONS TEMPTR
EXECUTABLE:INFO:LIST)))))
)
(RETURN TEMPTR))))))
(PRIN1 "SORRY, I CANNOT TRANSLATE THIS.")
(RETURN NIL))
EXPLICIT:ARGS:CHECK (OR (MEMBER (EVAL NEW:INFO)
NEW:INFO:LIST)
(NULL (EVAL NEW:INFO))
FORCE:TRANSLATE
(COND (NEW:INFO:LIST (SETQQ NEW:INFO UNKNOWN:TASK)
(SET NEW:INFO (CAR NEW:INFO:LIST)))))
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS (((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1))))
MINOR:EFFECTS ((VECTOR NEW INFO))
AFFECTS (QUOTE ((LOOKUP CALLED)
(PARSE CALLED)))
COMPLEXITY:VECTOR (.3 .5 .5 .5)
COMMENTS ((SETQ EV:NEW:INFO (EVAL NEW:INFO)))
IMPLICIT:ARGS (EV:NEW:INFO PART1 PART2))
(PUTPROPS USE:INFORMATION BEING T
IMPLICIT:ARGS (ACTION)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK EXECUTABLE:INFO:LIST
WHAT (TUPLE USE SOME AVAILABLE INFORMATION)
HOW (TUPLE PICK ONE OF (@ EXECUTABLE:INFO:LIST)
AND DO IT)
WHY (TUPLE IF WE DON'T DO WHAT WE CAN AS SOON AS POSSIBLE, WE MIGHT NEEDLESSLY BOTHER THE
USER, OUR SLOWEST CHANNNEL)
WHEN ((EXECUTABLE:INFO:LIST 120
(TUPLE BECAUSE WE COULD BE GOING IN CIRCLES IF WE DON'T DO WHAT
WE CAN AS SOON AS POSSIBLE)))
META:CODE (PROGN (SETQ ACTION (COND ((GETP (CAR (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))
NON:EVAL:ARGS)
(COND ((EQUAL (CAAR EXECUTABLE:INFO:LIST)
VECTOR)
(CDAR EXECUTABLE:INFO:LIST))
(T (CAR EXECUTABLE:INFO:LIST))))
(T (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))))
(SETQ EXECUTABLE:INFO:LIST (CDR EXECUTABLE:INFO:LIST))
(COND ((EVAL ACTION))
(T (NCONC1 EXECUTABLE:INFO:LIST ACTION)
NIL)))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS UTILIZE BEING T
IDEN (((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI))))
IMPLICIT:ARGS (KNOW:LIST DEC)
EXPLICIT:ARGS (KNOW:NAME APPLIED:SO:AS:TO:KEEP INVARIANT)
EXPLICIT:ARGS:CHECK (AND (EQUAL (CAR INVARIANT)
VECTOR)
(MEMBER (CADR INVARIANT)
(QUOTE (RELEVANT IRRELEVANT)))
(ATOM KNOW:NAME)
(OR (NULL (EVAL KNOW:NAME))
(LISTP (EVAL KNOW:NAME))))
WHAT (TUPLE USE THE LIST (@ KNOW:LIST)
OF INFORMATION TO DECIDE THE TURNING POINT OF THE TRUTH OF THE PREDICATE (@ INVARIANT))
HOW (TUPLE SEARCH THROUGH (@ KNOW:LIST)
FOR APPLICABLE RULES)
WHY (TUPLE SO PUP KNOWS WHEN (@ INVARIANT)
CHANGES TRUTH VALUE)
META:CODE (PROG (AF HOLD:ANY2)
(COND ((MATCH (VECTOR ANY2 (VECTOR PUP REINVESTIGATE FRAG1))
INVARIANT)
(SETQ HOLD:ANY2 ANY2)
(SETQ DEC (CONS VECTOR FRAG1))
(COND ((AND (SETQ AF (CADR (MEMBER WHEN DEC)))
(MAPC (EVAL (COLON:BACK (CONS WHEN:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((AND (SETQ AF (CADR (MEMBER AFFECTS DEC)))
(MAPC (EVAL (COLON:BACK (CONS AFFECTS:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((MAPC KNOW:LIST (FUNCTION (LAMBDA (K)
(COND ((SETQ AF (EVAL K))
(RETURN (VECTOR
(OPPOSITE
HOLD:ANY2)
(@ AF)))))))))
(T (RETURN NIL))))
(T (RETURN NIL))))
COMMENTS ((OR (SETQ KNOW:LIST (EVAL KNOW:NAME))
T))
COMPLEXITY:VECTOR (.5 .5 .5 .5))
(PUTPROPS WHEN:NEXT BEING T
IDEN (((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI))))
IMPLICIT:ARGS (UTILIZATION UTIL2 AWARE:LIST)
EXPLICIT:ARGS (ACT)
EXPLICIT:ARGS:CHECK (AND (MEMBER (CADR ACT)
(QUOTE (USER PUP)))
(EQUAL (LENGTH ACT)
4))
WHAT (TUPLE FIND THE NEXT SITUATION IN WHICH (CADR ACT)
MUST PERFORM THE OPERATION (CADDR ACT)
ON
(CADDDR ACT))
HOW (TUPLE EXPLORE THE EFFECTS OF (CADDR ACT)
ING
(CADDDR ACT))
WHY (TUPLE (CADR ACT)
CAN THEN FORGET (CADDDR ACT)
UNTIL THE NEXT SITUATION WE FIND HERE)
MAIN:EFFECTS (((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2)))))
META:CODE (PROGN (SETQ RELEVANT:KNOWLEDGE (COLON:BACK (COPY (TUPLE (CADR (CADDDR ACT))
(CADR BEING:STACK)
KNOWLEDGE))))
(SETQ UTILIZATION (VECTOR DELAYABLE (@ ACT)
UNTIL
(SETQ UTIL2 (UTILIZE
RELEVANT:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
(VECTOR IRRELEVANT (APPEND
(VECTOR (CADR ACT)
(CADDR ACT))
(CDDAR (CDDDR ACT))))))))
(SETQ AWARE:LIST (COLON:BACK (COPY (LIST (QUOTE AWARE)
(CADR ACT)
(QUOTE LIST)))))
(SET AWARE:LIST (CONS UTILIZATION (EVAL AWARE:LIST)))
UTIL2)
COMPLEXITY:VECTOR (.6 .7 .5 .5))
(PUTPROPS WRITE:PROGRAM IDEN (((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T))))
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES (@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE WRITTEN TO DO
(@ TASK)
IN ORDER THAT THE TASK (@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE SPEC:WHY)
WHEN ((T (COND ((MEMBER TASK ABLE:PUP:LIST)
-75)
(T 40))
(TUPLE BECAUSE A PRE:EXISTING ABILITY TO DO (@ TASK)
IMPLIES THAT WRITING A NEW PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
CONVERSELY, THE INABILITY TO DO (@ TASK)
ABDUCTIVELY ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
((MEMBER TASK WRITTEN:PROGRAMS:LIST)
-80
(QUOTE (BECAUSE WE ARE NOT AFTER MUCH EFFICIENCY, AND IF A PROGRAM ALREADY EXISTS,
THEN WE SHOULD USE IT)))
((MEMBER (TUPLE PUP IS ABOUT TO WRITE A PROGRAM TO DO (@ TASK))
AWARE:USER:LIST)
70
(QUOTE (BECAUSE WE GO BY THE OLD ENGLISH LEGAL RULE, THAT SILENCE SIGNIFIES APPROVAL)))
(T (COND (NEW:INFO:LIST -120)
(T 40))
(QUOTE (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE WRITING PROGRAMS ALSO:
BECAUSE IF NO NEW INFO IS PRESENT, THEN WE NEEDN'T FEEL GUILTY ABOUT
STARTING TO WRITE A PROGRAM))))
META:CODE (PROG (DONE PGM)
(SETQ PGM (VECTOR))
(SETQ UNDEFINED:SECTION:LIST (CONS (VECTOR (@ TASK:NAME)
TYPE OF (@ TASK))
UNDEFINED:SECTION:LIST))
LABEL4
(COND ((MEMBER TASK:NAME WRITTEN:PROGRAMS:LIST)
(SETQ WRITTEN:PROGRAMS:LIST (CONS TASK WRITTEN:PROGRAMS:LIST))
(SETQ ABLE:PUP:LIST (CONS TASK ABLE:PUP:LIST))
(SETQ ABLE:USER:LIST (CONS TASK ABLE:USER:LIST))
(RETURN T))
((NOT (MEMBER NIL (MAPCAR (APPEND USER:INTERRUPT:DEMONS CURRENT:DEMONS)
(QUOTE APPLY*))))
(CHOOSE:FROM (QUOTE ((OBTAIN:USABLE:INFORMATION (QUOTE PGM))
(USE:INFORMATION (QUOTE PGM))
(FILL:IN:UNDEFINED:SECTION (QUOTE PGM))
(CLARIFY:IMPROBABLE:SITUATION (QUOTE PGM))
(ADAPT:PRECONCEIVED:FUNCTION (QUOTE PGM))
(FIX:INCORRECT:PIECE (QUOTE PGM)))))
(GO LABEL4))
(T (RETURN NIL))))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WRITE A PROGRAM TO DO
(@ TASK)))
(VECTOR NAMED EXPRESSION (@ TASK)
(VECTOR TASK:NAME))
(VECTOR AWARE USER (VECTOR THE NAME OF THE PROGRAM TO DO (@ TASK)
IS
(@ TASK:NAME)))
(VECTOR TYPE OF (VECTOR (@ TASK)
HAS BEEN STUDIED)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR THE PROGRAM (@ TASK:NAME)
TO DO (@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATION:DEMON)
MAIN:EFFECTS (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1))))
AFFECTS (QUOTE ((OBTAIN:USABLE:INFORMATION POSSIBLE:CALLED)
(USE:INFORMATION POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION POSSIBLE:CALLED)))
COMPLEXITY:VECTOR ((PLUS .3 (TIMES .6 (DIMENSION1 TASK:TYPE)))
.9 .7 .5))
(MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(WIDEPAPER T)
(MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")
STOP